home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / get_old.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  123KB  |  3,599 lines
  1. /* $Id: get.c,v 3.15 1998/07/29 04:09:33 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: get.c,v $
  26.  * Revision 3.15  1998/07/29 04:09:33  brianp
  27.  * getting polygon stipple on/off state was broken
  28.  *
  29.  * Revision 3.14  1998/07/18 03:32:54  brianp
  30.  * added GL_SELECTION_BUFFER_SIZE GL_SELECTION_BUFFER_POINTER cases
  31.  *
  32.  * Revision 3.13  1998/06/19 03:10:50  brianp
  33.  * glGet(MODELVIEW/PROJECTION/MATRIX_STACK_DEPTH) was off by one
  34.  *
  35.  * Revision 3.12  1998/06/07 22:18:52  brianp
  36.  * implemented GL_EXT_multitexture extension
  37.  *
  38.  * Revision 3.11  1998/05/31 23:50:36  brianp
  39.  * cleaned up a few Solaris compiler warnings
  40.  *
  41.  * Revision 3.10  1998/04/01 02:59:42  brianp
  42.  * updated for v0.24 of 3Dfx/Glide driver
  43.  *
  44.  * Revision 3.9  1998/03/27 03:37:40  brianp
  45.  * fixed G++ warnings
  46.  *
  47.  * Revision 3.8  1998/02/21 01:02:03  brianp
  48.  * query driver for max number of textures
  49.  *
  50.  * Revision 3.7  1998/02/20 04:50:44  brianp
  51.  * implemented GL_SGIS_multitexture
  52.  *
  53.  * Revision 3.6  1998/02/13 03:23:04  brianp
  54.  * AlphaRef is now a GLubyte
  55.  *
  56.  * Revision 3.5  1998/02/08 20:19:41  brianp
  57.  * ColorMask is now GLubyte[4] instead of GLuint
  58.  *
  59.  * Revision 3.4  1998/02/07 14:43:46  brianp
  60.  * get GL_MAX_TEXTURE_SIZE now queries device driver
  61.  *
  62.  * Revision 3.3  1998/02/04 05:00:07  brianp
  63.  * added a few casts for Amiga StormC compiler
  64.  *
  65.  * Revision 3.2  1998/02/02 03:09:34  brianp
  66.  * added GL_LIGHT_MODEL_COLOR_CONTROL (separate specular color interpolation)
  67.  *
  68.  * Revision 3.1  1998/02/01 20:05:10  brianp
  69.  * added glDrawRangeElements()
  70.  *
  71.  * Revision 3.0  1998/01/31 20:53:22  brianp
  72.  * initial rev
  73.  *
  74.  */
  75.  
  76.  
  77. #ifdef PC_HEADER
  78. #include "all.h"
  79. #else
  80. #include <assert.h>
  81. #include <string.h>
  82. #include "context.h"
  83. #include "get.h"
  84. #include "macros.h"
  85. #include "types.h"
  86. #include "vb.h"
  87. #endif
  88.  
  89.  
  90.  
  91. #define FLOAT_TO_BOOL(X)        ( (X)==0.0F ? GL_FALSE : GL_TRUE )
  92. #define INT_TO_BOOL(I)          ( (I)==0 ? GL_FALSE : GL_TRUE )
  93. #define ENUM_TO_BOOL(E)         ( (E)==0 ? GL_FALSE : GL_TRUE )
  94.  
  95. #ifdef SPECIALCAST
  96. /* Needed for an Amiga compiler */
  97. #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
  98. #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
  99. #else
  100. /* all other compilers */
  101. #define ENUM_TO_FLOAT(X) ((GLfloat)(X))
  102. #define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
  103. #endif
  104.  
  105.  
  106.  
  107. /*
  108.  * Return max number of simultaneous textures.
  109.  */
  110. static GLint max_textures(const GLcontext *ctx)
  111. {
  112.    if (ctx->Driver.GetParameteri) {
  113.       GLint maxSets = (*ctx->Driver.GetParameteri)(ctx, DD_MAX_TEXTURES);
  114.       assert(maxSets >= 1 && maxSets <= MAX_TEX_SETS);
  115.       return maxSets;
  116.    }
  117.    else {
  118.       return MAX_TEX_SETS;
  119.    }
  120. }
  121.  
  122.  
  123.  
  124. /*
  125.  * Return max texture size.
  126.  */
  127. static GLint max_texture_size(const GLcontext *ctx)
  128. {
  129.    if (ctx->Driver.GetParameteri)
  130.       return (ctx->Driver.GetParameteri)(ctx, DD_MAX_TEXTURE_SIZE);
  131.    else
  132.       return MAX_TEXTURE_SIZE;
  133. }
  134.  
  135.  
  136.  
  137. void gl_GetBooleanv( GLcontext *ctx, GLenum pname, GLboolean *params )
  138. {
  139.    GLuint i;
  140.    GLuint texSet = ctx->Texture.CurrentSet;
  141.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  142.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  143.  
  144.    if (INSIDE_BEGIN_END(ctx)) {
  145.       gl_error( ctx, GL_INVALID_OPERATION, "glGetBooleanv" );
  146.       return;
  147.    }
  148.  
  149.    switch (pname) {
  150.       case GL_ACCUM_RED_BITS:
  151.       case GL_ACCUM_GREEN_BITS:
  152.       case GL_ACCUM_BLUE_BITS:
  153.       case GL_ACCUM_ALPHA_BITS:
  154.          *params = INT_TO_BOOL(ctx->Visual->AccumBits);
  155.          break;
  156.       case GL_ACCUM_CLEAR_VALUE:
  157.          params[0] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[0]);
  158.          params[1] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[1]);
  159.          params[2] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[2]);
  160.          params[3] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[3]);
  161.          break;
  162.       case GL_ALPHA_BIAS:
  163.          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaBias);
  164.          break;
  165.       case GL_ALPHA_BITS:
  166.          *params = INT_TO_BOOL(ctx->Visual->AlphaBits);
  167.          break;
  168.       case GL_ALPHA_SCALE:
  169.          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaScale);
  170.          break;
  171.       case GL_ALPHA_TEST:
  172.          *params = ctx->Color.AlphaEnabled;
  173.          break;
  174.       case GL_ALPHA_TEST_FUNC:
  175.          *params = ENUM_TO_BOOL(ctx->Color.AlphaFunc);
  176.          break;
  177.       case GL_ALPHA_TEST_REF:
  178.          *params = FLOAT_TO_BOOL((GLfloat) ctx->Color.AlphaRef / 255.0);
  179.          break;
  180.       case GL_ATTRIB_STACK_DEPTH:
  181.          *params = INT_TO_BOOL(ctx->AttribStackDepth);
  182.          break;
  183.       case GL_AUTO_NORMAL:
  184.          *params = ctx->Eval.AutoNormal;
  185.          break;
  186.       case GL_AUX_BUFFERS:
  187.          *params = (NUM_AUX_BUFFERS) ? GL_TRUE : GL_FALSE;
  188.          break;
  189.       case GL_BLEND:
  190.          *params = ctx->Color.BlendEnabled;
  191.          break;
  192.       case GL_BLEND_DST:
  193.          *params = ENUM_TO_BOOL(ctx->Color.BlendDst);
  194.          break;
  195.       case GL_BLEND_SRC:
  196.          *params = ENUM_TO_BOOL(ctx->Color.BlendSrc);
  197.          break;
  198.       case GL_BLEND_EQUATION_EXT:
  199.          *params = ENUM_TO_BOOL( ctx->Color.BlendEquation );
  200.          break;
  201.       case GL_BLEND_COLOR_EXT:
  202.          params[0] = FLOAT_TO_BOOL( ctx->Color.BlendColor[0] );
  203.          params[1] = FLOAT_TO_BOOL( ctx->Color.BlendColor[1] );
  204.          params[2] = FLOAT_TO_BOOL( ctx->Color.BlendColor[2] );
  205.          params[3] = FLOAT_TO_BOOL( ctx->Color.BlendColor[3] );
  206.          break;
  207.       case GL_BLUE_BIAS:
  208.          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueBias);
  209.          break;
  210.       case GL_BLUE_BITS:
  211.          *params = INT_TO_BOOL( ctx->Visual->BlueBits );
  212.          break;
  213.       case GL_BLUE_SCALE:
  214.          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueScale);
  215.          break;
  216.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  217.          *params = INT_TO_BOOL(ctx->ClientAttribStackDepth);
  218.          break;
  219.       case GL_CLIP_PLANE0:
  220.       case GL_CLIP_PLANE1:
  221.       case GL_CLIP_PLANE2:
  222.       case GL_CLIP_PLANE3:
  223.       case GL_CLIP_PLANE4:
  224.       case GL_CLIP_PLANE5:
  225.          *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  226.          break;
  227.       case GL_COLOR_CLEAR_VALUE:
  228.          params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
  229.          params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
  230.          params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
  231.          params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
  232.          break;
  233.       case GL_COLOR_MATERIAL:
  234.          *params = ctx->Light.ColorMaterialEnabled;
  235.          break;
  236.       case GL_COLOR_MATERIAL_FACE:
  237.          *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialFace);
  238.          break;
  239.       case GL_COLOR_MATERIAL_PARAMETER:
  240.          *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialMode);
  241.          break;
  242.       case GL_COLOR_WRITEMASK:
  243.          params[0] = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
  244.          params[1] = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
  245.          params[2] = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
  246.          params[3] = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
  247.          break;
  248.       case GL_CULL_FACE:
  249.          *params = ctx->Polygon.CullFlag;
  250.          break;
  251.       case GL_CULL_FACE_MODE:
  252.          *params = ENUM_TO_BOOL(ctx->Polygon.CullFaceMode);
  253.          break;
  254.       case GL_CURRENT_COLOR:
  255.          params[0] = INT_TO_BOOL(ctx->Current.ByteColor[0]);
  256.          params[1] = INT_TO_BOOL(ctx->Current.ByteColor[1]);
  257.          params[2] = INT_TO_BOOL(ctx->Current.ByteColor[2]);
  258.          params[3] = INT_TO_BOOL(ctx->Current.ByteColor[3]);
  259.          break;
  260.       case GL_CURRENT_INDEX:
  261.          *params = INT_TO_BOOL(ctx->Current.Index);
  262.          break;
  263.       case GL_CURRENT_NORMAL:
  264.          params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
  265.          params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
  266.          params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
  267.          break;
  268.       case GL_CURRENT_RASTER_COLOR:
  269.          params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]);
  270.          params[1] = FLOAT_TO_BOOL(ctx->Current.RasterColor[1]);
  271.          params[2] = FLOAT_TO_BOOL(ctx->Current.RasterColor[2]);
  272.          params[3] = FLOAT_TO_BOOL(ctx->Current.RasterColor[3]);
  273.          break;
  274.       case GL_CURRENT_RASTER_DISTANCE:
  275.          *params = FLOAT_TO_BOOL(ctx->Current.RasterDistance);
  276.          break;
  277.       case GL_CURRENT_RASTER_INDEX:
  278.          *params = FLOAT_TO_BOOL(ctx->Current.RasterIndex);
  279.          break;
  280.       case GL_CURRENT_RASTER_POSITION:
  281.          params[0] = FLOAT_TO_BOOL(ctx->Current.RasterPos[0]);
  282.          params[1] = FLOAT_TO_BOOL(ctx->Current.RasterPos[1]);
  283.          params[2] = FLOAT_TO_BOOL(ctx->Current.RasterPos[2]);
  284.          params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]);
  285.          break;
  286.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  287.          params[0] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][0]);
  288.          params[1] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][1]);
  289.          params[2] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][2]);
  290.          params[3] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformSet][3]);
  291.          break;
  292.       case GL_CURRENT_RASTER_POSITION_VALID:
  293.          *params = ctx->Current.RasterPosValid;
  294.          break;
  295.       case GL_CURRENT_TEXTURE_COORDS:
  296.          params[0] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][0]);
  297.          params[1] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][1]);
  298.          params[2] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][2]);
  299.          params[3] = FLOAT_TO_BOOL(ctx->Current.MultiTexCoord[texTransformSet][3]);
  300.          break;
  301.       case GL_DEPTH_BIAS:
  302.          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
  303.          break;
  304.       case GL_DEPTH_BITS:
  305.          *params = INT_TO_BOOL(ctx->Visual->DepthBits);
  306.          break;
  307.       case GL_DEPTH_CLEAR_VALUE:
  308.          *params = FLOAT_TO_BOOL(ctx->Depth.Clear);
  309.          break;
  310.       case GL_DEPTH_FUNC:
  311.          *params = ENUM_TO_BOOL(ctx->Depth.Func);
  312.          break;
  313.       case GL_DEPTH_RANGE:
  314.          params[0] = FLOAT_TO_BOOL(ctx->Viewport.Near);
  315.          params[1] = FLOAT_TO_BOOL(ctx->Viewport.Far);
  316.          break;
  317.       case GL_DEPTH_SCALE:
  318.          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthScale);
  319.          break;
  320.       case GL_DEPTH_TEST:
  321.          *params = ctx->Depth.Test;
  322.          break;
  323.       case GL_DEPTH_WRITEMASK:
  324.          *params = ctx->Depth.Mask;
  325.          break;
  326.       case GL_DITHER:
  327.          *params = ctx->Color.DitherFlag;
  328.          break;
  329.       case GL_DOUBLEBUFFER:
  330.          *params = ctx->Visual->DBflag;
  331.          break;
  332.       case GL_DRAW_BUFFER:
  333.          *params = ENUM_TO_BOOL(ctx->Color.DrawBuffer);
  334.          break;
  335.       case GL_EDGE_FLAG:
  336.          *params = ctx->Current.EdgeFlag;
  337.          break;
  338.       case GL_FEEDBACK_BUFFER_SIZE:
  339.          /* TODO: is this right?  Or, return number of entries in buffer? */
  340.          *params = INT_TO_BOOL(ctx->Feedback.BufferSize);
  341.          break;
  342.       case GL_FEEDBACK_BUFFER_TYPE:
  343.          *params = INT_TO_BOOL(ctx->Feedback.Type);
  344.          break;
  345.       case GL_FOG:
  346.          *params = ctx->Fog.Enabled;
  347.          break;
  348.       case GL_FOG_COLOR:
  349.          params[0] = FLOAT_TO_BOOL(ctx->Fog.Color[0]);
  350.          params[1] = FLOAT_TO_BOOL(ctx->Fog.Color[1]);
  351.          params[2] = FLOAT_TO_BOOL(ctx->Fog.Color[2]);
  352.          params[3] = FLOAT_TO_BOOL(ctx->Fog.Color[3]);
  353.          break;
  354.       case GL_FOG_DENSITY:
  355.          *params = FLOAT_TO_BOOL(ctx->Fog.Density);
  356.          break;
  357.       case GL_FOG_END:
  358.          *params = FLOAT_TO_BOOL(ctx->Fog.End);
  359.          break;
  360.       case GL_FOG_HINT:
  361.          *params = ENUM_TO_BOOL(ctx->Hint.Fog);
  362.          break;
  363.       case GL_FOG_INDEX:
  364.          *params = FLOAT_TO_BOOL(ctx->Fog.Index);
  365.          break;
  366.       case GL_FOG_MODE:
  367.          *params = ENUM_TO_BOOL(ctx->Fog.Mode);
  368.          break;
  369.       case GL_FOG_START:
  370.          *params = FLOAT_TO_BOOL(ctx->Fog.End);
  371.          break;
  372.       case GL_FRONT_FACE:
  373.          *params = ENUM_TO_BOOL(ctx->Polygon.FrontFace);
  374.          break;
  375.       case GL_GREEN_BIAS:
  376.          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenBias);
  377.          break;
  378.       case GL_GREEN_BITS:
  379.          *params = INT_TO_BOOL( ctx->Visual->GreenBits );
  380.          break;
  381.       case GL_GREEN_SCALE:
  382.          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
  383.          break;
  384.       case GL_INDEX_BITS:
  385.          *params = INT_TO_BOOL( ctx->Visual->IndexBits );
  386.          break;
  387.       case GL_INDEX_CLEAR_VALUE:
  388.          *params = INT_TO_BOOL(ctx->Color.ClearIndex);
  389.          break;
  390.       case GL_INDEX_MODE:
  391.          *params = ctx->Visual->RGBAflag ? GL_FALSE : GL_TRUE;
  392.          break;
  393.       case GL_INDEX_OFFSET:
  394.          *params = INT_TO_BOOL(ctx->Pixel.IndexOffset);
  395.          break;
  396.       case GL_INDEX_SHIFT:
  397.          *params = INT_TO_BOOL(ctx->Pixel.IndexShift);
  398.          break;
  399.       case GL_INDEX_WRITEMASK:
  400.          *params = INT_TO_BOOL(ctx->Color.IndexMask);
  401.          break;
  402.       case GL_LIGHT0:
  403.       case GL_LIGHT1:
  404.       case GL_LIGHT2:
  405.       case GL_LIGHT3:
  406.       case GL_LIGHT4:
  407.       case GL_LIGHT5:
  408.       case GL_LIGHT6:
  409.       case GL_LIGHT7:
  410.          *params = ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  411.          break;
  412.       case GL_LIGHTING:
  413.          *params = ctx->Light.Enabled;
  414.          break;
  415.       case GL_LIGHT_MODEL_AMBIENT:
  416.          params[0] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[0]);
  417.          params[1] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[1]);
  418.          params[2] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[2]);
  419.          params[3] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[3]);
  420.          break;
  421.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  422.          params[0] = ENUM_TO_BOOL(ctx->Light.Model.ColorControl);
  423.          break;
  424.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  425.          *params = ctx->Light.Model.LocalViewer;
  426.          break;
  427.       case GL_LIGHT_MODEL_TWO_SIDE:
  428.          *params = ctx->Light.Model.TwoSide;
  429.          break;
  430.       case GL_LINE_SMOOTH:
  431.          *params = ctx->Line.SmoothFlag;
  432.          break;
  433.       case GL_LINE_SMOOTH_HINT:
  434.          *params = ENUM_TO_BOOL(ctx->Hint.LineSmooth);
  435.          break;
  436.       case GL_LINE_STIPPLE:
  437.          *params = ctx->Line.StippleFlag;
  438.          break;
  439.       case GL_LINE_STIPPLE_PATTERN:
  440.          *params = INT_TO_BOOL(ctx->Line.StipplePattern);
  441.          break;
  442.       case GL_LINE_STIPPLE_REPEAT:
  443.          *params = INT_TO_BOOL(ctx->Line.StippleFactor);
  444.          break;
  445.       case GL_LINE_WIDTH:
  446.          *params = FLOAT_TO_BOOL(ctx->Line.Width);
  447.          break;
  448.       case GL_LINE_WIDTH_GRANULARITY:
  449.          *params = FLOAT_TO_BOOL(LINE_WIDTH_GRANULARITY);
  450.          break;
  451.       case GL_LINE_WIDTH_RANGE:
  452.          params[0] = FLOAT_TO_BOOL(MIN_LINE_WIDTH);
  453.          params[1] = FLOAT_TO_BOOL(MAX_LINE_WIDTH);
  454.          break;
  455.       case GL_LIST_BASE:
  456.          *params = INT_TO_BOOL(ctx->List.ListBase);
  457.          break;
  458.       case GL_LIST_INDEX:
  459.          *params = INT_TO_BOOL( ctx->CurrentListNum );
  460.          break;
  461.       case GL_LIST_MODE:
  462.          *params = ENUM_TO_BOOL( ctx->ExecuteFlag
  463.                                   ? GL_COMPILE_AND_EXECUTE : GL_COMPILE );
  464.          break;
  465.       case GL_INDEX_LOGIC_OP:
  466.          *params = ctx->Color.IndexLogicOpEnabled;
  467.          break;
  468.       case GL_COLOR_LOGIC_OP:
  469.          *params = ctx->Color.ColorLogicOpEnabled;
  470.          break;
  471.       case GL_LOGIC_OP_MODE:
  472.          *params = ENUM_TO_BOOL(ctx->Color.LogicOp);
  473.          break;
  474.       case GL_MAP1_COLOR_4:
  475.          *params = ctx->Eval.Map1Color4;
  476.          break;
  477.       case GL_MAP1_GRID_DOMAIN:
  478.          params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u1);
  479.          params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u2);
  480.          break;
  481.       case GL_MAP1_GRID_SEGMENTS:
  482.          *params = INT_TO_BOOL(ctx->Eval.MapGrid1un);
  483.          break;
  484.       case GL_MAP1_INDEX:
  485.          *params = ctx->Eval.Map1Index;
  486.          break;
  487.       case GL_MAP1_NORMAL:
  488.          *params = ctx->Eval.Map1Normal;
  489.          break;
  490.       case GL_MAP1_TEXTURE_COORD_1:
  491.          *params = ctx->Eval.Map1TextureCoord1;
  492.          break;
  493.       case GL_MAP1_TEXTURE_COORD_2:
  494.          *params = ctx->Eval.Map1TextureCoord2;
  495.          break;
  496.       case GL_MAP1_TEXTURE_COORD_3:
  497.          *params = ctx->Eval.Map1TextureCoord3;
  498.          break;
  499.       case GL_MAP1_TEXTURE_COORD_4:
  500.          *params = ctx->Eval.Map1TextureCoord4;
  501.          break;
  502.       case GL_MAP1_VERTEX_3:
  503.          *params = ctx->Eval.Map1Vertex3;
  504.          break;
  505.       case GL_MAP1_VERTEX_4:
  506.          *params = ctx->Eval.Map1Vertex4;
  507.          break;
  508.       case GL_MAP2_COLOR_4:
  509.          *params = ctx->Eval.Map2Color4;
  510.          break;
  511.       case GL_MAP2_GRID_DOMAIN:
  512.          params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u1);
  513.          params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u2);
  514.          params[2] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v1);
  515.          params[3] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v2);
  516.          break;
  517.       case GL_MAP2_GRID_SEGMENTS:
  518.          params[0] = INT_TO_BOOL(ctx->Eval.MapGrid2un);
  519.          params[1] = INT_TO_BOOL(ctx->Eval.MapGrid2vn);
  520.          break;
  521.       case GL_MAP2_INDEX:
  522.          *params = ctx->Eval.Map2Index;
  523.          break;
  524.       case GL_MAP2_NORMAL:
  525.          *params = ctx->Eval.Map2Normal;
  526.          break;
  527.       case GL_MAP2_TEXTURE_COORD_1:
  528.          *params = ctx->Eval.Map2TextureCoord1;
  529.          break;
  530.       case GL_MAP2_TEXTURE_COORD_2:
  531.          *params = ctx->Eval.Map2TextureCoord2;
  532.          break;
  533.       case GL_MAP2_TEXTURE_COORD_3:
  534.          *params = ctx->Eval.Map2TextureCoord3;
  535.          break;
  536.       case GL_MAP2_TEXTURE_COORD_4:
  537.          *params = ctx->Eval.Map2TextureCoord4;
  538.          break;
  539.       case GL_MAP2_VERTEX_3:
  540.          *params = ctx->Eval.Map2Vertex3;
  541.          break;
  542.       case GL_MAP2_VERTEX_4:
  543.          *params = ctx->Eval.Map2Vertex4;
  544.          break;
  545.       case GL_MAP_COLOR:
  546.          *params = ctx->Pixel.MapColorFlag;
  547.          break;
  548.       case GL_MAP_STENCIL:
  549.          *params = ctx->Pixel.MapStencilFlag;
  550.          break;
  551.       case GL_MATRIX_MODE:
  552.          *params = ENUM_TO_BOOL( ctx->Transform.MatrixMode );
  553.          break;
  554.       case GL_MAX_ATTRIB_STACK_DEPTH:
  555.          *params = INT_TO_BOOL(MAX_ATTRIB_STACK_DEPTH);
  556.          break;
  557.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  558.          *params = INT_TO_BOOL( MAX_CLIENT_ATTRIB_STACK_DEPTH);
  559.          break;
  560.       case GL_MAX_CLIP_PLANES:
  561.          *params = INT_TO_BOOL(MAX_CLIP_PLANES);
  562.          break;
  563.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  564.          *params = INT_TO_BOOL(VB_MAX);
  565.          break;
  566.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  567.          *params = INT_TO_BOOL(VB_MAX);
  568.          break;
  569.       case GL_MAX_EVAL_ORDER:
  570.          *params = INT_TO_BOOL(MAX_EVAL_ORDER);
  571.          break;
  572.       case GL_MAX_LIGHTS:
  573.          *params = INT_TO_BOOL(MAX_LIGHTS);
  574.          break;
  575.       case GL_MAX_LIST_NESTING:
  576.          *params = INT_TO_BOOL(MAX_LIST_NESTING);
  577.          break;
  578.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  579.          *params = INT_TO_BOOL(MAX_MODELVIEW_STACK_DEPTH);
  580.          break;
  581.       case GL_MAX_NAME_STACK_DEPTH:
  582.          *params = INT_TO_BOOL(MAX_NAME_STACK_DEPTH);
  583.          break;
  584.       case GL_MAX_PIXEL_MAP_TABLE:
  585.          *params = INT_TO_BOOL(MAX_PIXEL_MAP_TABLE);
  586.          break;
  587.       case GL_MAX_PROJECTION_STACK_DEPTH:
  588.          *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH);
  589.          break;
  590.       case GL_MAX_TEXTURE_SIZE:
  591.          *params = INT_TO_BOOL(max_texture_size(ctx));
  592.          break;
  593.       case GL_MAX_TEXTURE_STACK_DEPTH:
  594.          *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH);
  595.          break;
  596.       case GL_MAX_VIEWPORT_DIMS:
  597.          params[0] = INT_TO_BOOL(MAX_WIDTH);
  598.          params[1] = INT_TO_BOOL(MAX_HEIGHT);
  599.          break;
  600.       case GL_MODELVIEW_MATRIX:
  601.          for (i=0;i<16;i++) {
  602.             params[i] = FLOAT_TO_BOOL(ctx->ModelViewMatrix[i]);
  603.          }
  604.          break;
  605.       case GL_MODELVIEW_STACK_DEPTH:
  606.          *params = INT_TO_BOOL(ctx->ModelViewStackDepth + 1);
  607.          break;
  608.       case GL_NAME_STACK_DEPTH:
  609.          *params = INT_TO_BOOL(ctx->Select.NameStackDepth);
  610.          break;
  611.       case GL_NORMALIZE:
  612.          *params = ctx->Transform.Normalize;
  613.          break;
  614.       case GL_PACK_ALIGNMENT:
  615.          *params = INT_TO_BOOL(ctx->Pack.Alignment);
  616.          break;
  617.       case GL_PACK_LSB_FIRST:
  618.          *params = ctx->Pack.LsbFirst;
  619.          break;
  620.       case GL_PACK_ROW_LENGTH:
  621.          *params = INT_TO_BOOL(ctx->Pack.RowLength);
  622.          break;
  623.       case GL_PACK_SKIP_PIXELS:
  624.          *params = INT_TO_BOOL(ctx->Pack.SkipPixels);
  625.          break;
  626.       case GL_PACK_SKIP_ROWS:
  627.          *params = INT_TO_BOOL(ctx->Pack.SkipRows);
  628.          break;
  629.       case GL_PACK_SWAP_BYTES:
  630.          *params = ctx->Pack.SwapBytes;
  631.          break;
  632.       case GL_PACK_SKIP_IMAGES_EXT:
  633.          *params = ctx->Pack.SkipImages;
  634.          break;
  635.       case GL_PACK_IMAGE_HEIGHT_EXT:
  636.          *params = ctx->Pack.ImageHeight;
  637.          break;
  638.       case GL_PERSPECTIVE_CORRECTION_HINT:
  639.          *params = ENUM_TO_BOOL(ctx->Hint.PerspectiveCorrection);
  640.          break;
  641.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  642.          *params = INT_TO_BOOL(ctx->Pixel.MapAtoAsize);
  643.          break;
  644.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  645.          *params = INT_TO_BOOL(ctx->Pixel.MapBtoBsize);
  646.          break;
  647.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  648.          *params = INT_TO_BOOL(ctx->Pixel.MapGtoGsize);
  649.          break;
  650.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  651.          *params = INT_TO_BOOL(ctx->Pixel.MapItoAsize);
  652.          break;
  653.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  654.          *params = INT_TO_BOOL(ctx->Pixel.MapItoBsize);
  655.          break;
  656.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  657.          *params = INT_TO_BOOL(ctx->Pixel.MapItoGsize);
  658.          break;
  659.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  660.          *params = INT_TO_BOOL(ctx->Pixel.MapItoIsize);
  661.          break;
  662.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  663.          *params = INT_TO_BOOL(ctx->Pixel.MapItoRsize);
  664.          break;
  665.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  666.          *params = INT_TO_BOOL(ctx->Pixel.MapRtoRsize);
  667.          break;
  668.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  669.          *params = INT_TO_BOOL(ctx->Pixel.MapStoSsize);
  670.          break;
  671.       case GL_POINT_SIZE:
  672.          *params = FLOAT_TO_BOOL(ctx->Point.Size );
  673.          break;
  674.       case GL_POINT_SIZE_GRANULARITY:
  675.          *params = FLOAT_TO_BOOL(POINT_SIZE_GRANULARITY );
  676.          break;
  677.       case GL_POINT_SIZE_RANGE:
  678.          params[0] = FLOAT_TO_BOOL(MIN_POINT_SIZE );
  679.          params[1] = FLOAT_TO_BOOL(MAX_POINT_SIZE );
  680.          break;
  681.       case GL_POINT_SMOOTH:
  682.          *params = ctx->Point.SmoothFlag;
  683.          break;
  684.       case GL_POINT_SMOOTH_HINT:
  685.          *params = ENUM_TO_BOOL(ctx->Hint.PointSmooth);
  686.          break;
  687.       case GL_POINT_SIZE_MIN_EXT:
  688.          *params = FLOAT_TO_BOOL(ctx->Point.MinSize);
  689.          break;
  690.       case GL_POINT_SIZE_MAX_EXT:
  691.          *params = FLOAT_TO_BOOL(ctx->Point.MaxSize);
  692.          break;
  693.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  694.          *params = FLOAT_TO_BOOL(ctx->Point.Threshold);
  695.          break;
  696.       case GL_DISTANCE_ATTENUATION_EXT:
  697.          params[0] = FLOAT_TO_BOOL(ctx->Point.Params[0]);
  698.          params[1] = FLOAT_TO_BOOL(ctx->Point.Params[1]);
  699.          params[2] = FLOAT_TO_BOOL(ctx->Point.Params[2]);
  700.          break;
  701.       case GL_POLYGON_MODE:
  702.          params[0] = ENUM_TO_BOOL(ctx->Polygon.FrontMode);
  703.          params[1] = ENUM_TO_BOOL(ctx->Polygon.BackMode);
  704.          break;
  705. #ifdef GL_EXT_polygon_offset
  706.       case GL_POLYGON_OFFSET_BIAS_EXT:
  707.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
  708.          break;
  709. #endif
  710.       case GL_POLYGON_OFFSET_FACTOR:
  711.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetFactor );
  712.          break;
  713.       case GL_POLYGON_OFFSET_UNITS:
  714.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
  715.          break;
  716.       case GL_POLYGON_SMOOTH:
  717.          *params = ctx->Polygon.SmoothFlag;
  718.          break;
  719.       case GL_POLYGON_SMOOTH_HINT:
  720.          *params = ENUM_TO_BOOL(ctx->Hint.PolygonSmooth);
  721.          break;
  722.       case GL_POLYGON_STIPPLE:
  723.          *params = ctx->Polygon.StippleFlag;
  724.          break;
  725.       case GL_PROJECTION_MATRIX:
  726.          for (i=0;i<16;i++) {
  727.             params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrix[i]);
  728.          }
  729.          break;
  730.       case GL_PROJECTION_STACK_DEPTH:
  731.          *params = INT_TO_BOOL(ctx->ProjectionStackDepth + 1);
  732.          break;
  733.       case GL_READ_BUFFER:
  734.          *params = ENUM_TO_BOOL(ctx->Pixel.ReadBuffer);
  735.          break;
  736.       case GL_RED_BIAS:
  737.          *params = FLOAT_TO_BOOL(ctx->Pixel.RedBias);
  738.          break;
  739.       case GL_RED_BITS:
  740.          *params = INT_TO_BOOL( ctx->Visual->RedBits );
  741.          break;
  742.       case GL_RED_SCALE:
  743.          *params = FLOAT_TO_BOOL(ctx->Pixel.RedScale);
  744.          break;
  745.       case GL_RENDER_MODE:
  746.          *params = ENUM_TO_BOOL(ctx->RenderMode);
  747.          break;
  748.       case GL_RGBA_MODE:
  749.          *params = ctx->Visual->RGBAflag;
  750.          break;
  751.       case GL_SCISSOR_BOX:
  752.          params[0] = INT_TO_BOOL(ctx->Scissor.X);
  753.          params[1] = INT_TO_BOOL(ctx->Scissor.Y);
  754.          params[2] = INT_TO_BOOL(ctx->Scissor.Width);
  755.          params[3] = INT_TO_BOOL(ctx->Scissor.Height);
  756.          break;
  757.       case GL_SCISSOR_TEST:
  758.          *params = ctx->Scissor.Enabled;
  759.          break;
  760.       case GL_SELECTION_BUFFER_SIZE:
  761.          *params = INT_TO_BOOL(ctx->Select.BufferSize);
  762.          break;
  763.       case GL_SHADE_MODEL:
  764.          *params = ENUM_TO_BOOL(ctx->Light.ShadeModel);
  765.          break;
  766.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  767.          *params = ctx->Texture.SharedPalette;
  768.          break;
  769.       case GL_STENCIL_BITS:
  770.          *params = INT_TO_BOOL(ctx->Visual->StencilBits);
  771.          break;
  772.       case GL_STENCIL_CLEAR_VALUE:
  773.          *params = INT_TO_BOOL(ctx->Stencil.Clear);
  774.          break;
  775.       case GL_STENCIL_FAIL:
  776.          *params = ENUM_TO_BOOL(ctx->Stencil.FailFunc);
  777.          break;
  778.       case GL_STENCIL_FUNC:
  779.          *params = ENUM_TO_BOOL(ctx->Stencil.Function);
  780.          break;
  781.       case GL_STENCIL_PASS_DEPTH_FAIL:
  782.          *params = ENUM_TO_BOOL(ctx->Stencil.ZFailFunc);
  783.          break;
  784.       case GL_STENCIL_PASS_DEPTH_PASS:
  785.          *params = ENUM_TO_BOOL(ctx->Stencil.ZPassFunc);
  786.          break;
  787.       case GL_STENCIL_REF:
  788.          *params = INT_TO_BOOL(ctx->Stencil.Ref);
  789.          break;
  790.       case GL_STENCIL_TEST:
  791.          *params = ctx->Stencil.Enabled;
  792.          break;
  793.       case GL_STENCIL_VALUE_MASK:
  794.          *params = INT_TO_BOOL(ctx->Stencil.ValueMask);
  795.          break;
  796.       case GL_STENCIL_WRITEMASK:
  797.          *params = INT_TO_BOOL(ctx->Stencil.WriteMask);
  798.          break;
  799.       case GL_STEREO:
  800.          *params = GL_FALSE;    /* TODO */
  801.          break;
  802.       case GL_SUBPIXEL_BITS:
  803.          *params = INT_TO_BOOL(0);  /* TODO */
  804.          break;
  805.       case GL_TEXTURE_1D:
  806.          {
  807.             GLuint bit = TEXTURE0_1D << (texSet * 4);
  808.             *params = (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  809.          }
  810.          break;
  811.       case GL_TEXTURE_2D:
  812.          {
  813.             GLuint bit = TEXTURE0_2D << (texSet * 4);
  814.             *params = (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  815.          }
  816.          break;
  817.       case GL_TEXTURE_3D:
  818.          {
  819.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  820.             *params = (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  821.          }
  822.          break;
  823.       case GL_TEXTURE_BINDING_1D:
  824.          *params = INT_TO_BOOL(textureSet->Current1D->Name);
  825.           break;
  826.       case GL_TEXTURE_BINDING_2D:
  827.          *params = INT_TO_BOOL(textureSet->Current2D->Name);
  828.           break;
  829.       case GL_TEXTURE_BINDING_3D:
  830.          *params = INT_TO_BOOL(textureSet->Current2D->Name);
  831.           break;
  832.       case GL_TEXTURE_ENV_COLOR:
  833.          {
  834.             params[0] = FLOAT_TO_BOOL(textureSet->EnvColor[0]);
  835.             params[1] = FLOAT_TO_BOOL(textureSet->EnvColor[1]);
  836.             params[2] = FLOAT_TO_BOOL(textureSet->EnvColor[2]);
  837.             params[3] = FLOAT_TO_BOOL(textureSet->EnvColor[3]);
  838.          }
  839.          break;
  840.       case GL_TEXTURE_ENV_MODE:
  841.          *params = ENUM_TO_BOOL(textureSet->EnvMode);
  842.          break;
  843.       case GL_TEXTURE_GEN_S:
  844.          *params = (textureSet->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  845.          break;
  846.       case GL_TEXTURE_GEN_T:
  847.          *params = (textureSet->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  848.          break;
  849.       case GL_TEXTURE_GEN_R:
  850.          *params = (textureSet->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  851.          break;
  852.       case GL_TEXTURE_GEN_Q:
  853.          *params = (textureSet->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  854.          break;
  855.       case GL_TEXTURE_MATRIX:
  856.          for (i=0;i<16;i++) {
  857.             params[i] = FLOAT_TO_BOOL(ctx->TextureMatrix[texTransformSet][i]);
  858.          }
  859.          break;
  860.       case GL_TEXTURE_STACK_DEPTH:
  861.          *params = INT_TO_BOOL(ctx->TextureStackDepth[texTransformSet] + 1);
  862.          break;
  863.       case GL_UNPACK_ALIGNMENT:
  864.          *params = INT_TO_BOOL(ctx->Unpack.Alignment);
  865.          break;
  866.       case GL_UNPACK_LSB_FIRST:
  867.          *params = ctx->Unpack.LsbFirst;
  868.          break;
  869.       case GL_UNPACK_ROW_LENGTH:
  870.          *params = INT_TO_BOOL(ctx->Unpack.RowLength);
  871.          break;
  872.       case GL_UNPACK_SKIP_PIXELS:
  873.          *params = INT_TO_BOOL(ctx->Unpack.SkipPixels);
  874.          break;
  875.       case GL_UNPACK_SKIP_ROWS:
  876.          *params = INT_TO_BOOL(ctx->Unpack.SkipRows);
  877.          break;
  878.       case GL_UNPACK_SWAP_BYTES:
  879.          *params = ctx->Unpack.SwapBytes;
  880.          break;
  881.       case GL_UNPACK_SKIP_IMAGES_EXT:
  882.          *params = ctx->Unpack.SkipImages;
  883.          break;
  884.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  885.          *params = ctx->Unpack.ImageHeight;
  886.          break;
  887.       case GL_VIEWPORT:
  888.          params[0] = INT_TO_BOOL(ctx->Viewport.X);
  889.          params[1] = INT_TO_BOOL(ctx->Viewport.Y);
  890.          params[2] = INT_TO_BOOL(ctx->Viewport.Width);
  891.          params[3] = INT_TO_BOOL(ctx->Viewport.Height);
  892.          break;
  893.       case GL_ZOOM_X:
  894.          *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomX);
  895.          break;
  896.       case GL_ZOOM_Y:
  897.          *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomY);
  898.          break;
  899.       case GL_VERTEX_ARRAY_SIZE:
  900.          *params = INT_TO_BOOL(ctx->Array.VertexSize);
  901.          break;
  902.       case GL_VERTEX_ARRAY_TYPE:
  903.          *params = ENUM_TO_BOOL(ctx->Array.VertexType);
  904.          break;
  905.       case GL_VERTEX_ARRAY_STRIDE:
  906.          *params = INT_TO_BOOL(ctx->Array.VertexStride);
  907.          break;
  908.       case GL_VERTEX_ARRAY_COUNT_EXT:
  909.          *params = INT_TO_BOOL(0);
  910.          break;
  911.       case GL_NORMAL_ARRAY_TYPE:
  912.          *params = ENUM_TO_BOOL(ctx->Array.NormalType);
  913.          break;
  914.       case GL_NORMAL_ARRAY_STRIDE:
  915.          *params = INT_TO_BOOL(ctx->Array.NormalStride);
  916.          break;
  917.       case GL_NORMAL_ARRAY_COUNT_EXT:
  918.          *params = INT_TO_BOOL(0);
  919.          break;
  920.       case GL_COLOR_ARRAY_SIZE:
  921.          *params = INT_TO_BOOL(ctx->Array.ColorSize);
  922.          break;
  923.       case GL_COLOR_ARRAY_TYPE:
  924.          *params = ENUM_TO_BOOL(ctx->Array.ColorType);
  925.          break;
  926.       case GL_COLOR_ARRAY_STRIDE:
  927.          *params = INT_TO_BOOL(ctx->Array.ColorStride);
  928.          break;
  929.       case GL_COLOR_ARRAY_COUNT_EXT:
  930.          *params = INT_TO_BOOL(0);
  931.          break;
  932.       case GL_INDEX_ARRAY_TYPE:
  933.          *params = ENUM_TO_BOOL(ctx->Array.IndexType);
  934.          break;
  935.       case GL_INDEX_ARRAY_STRIDE:
  936.          *params = INT_TO_BOOL(ctx->Array.IndexStride);
  937.          break;
  938.       case GL_INDEX_ARRAY_COUNT_EXT:
  939.          *params = INT_TO_BOOL(0);
  940.          break;
  941.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  942.          *params = INT_TO_BOOL(ctx->Array.TexCoordSize[texSet]);
  943.          break;
  944.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  945.          *params = ENUM_TO_BOOL(ctx->Array.TexCoordType[texSet]);
  946.          break;
  947.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  948.          *params = INT_TO_BOOL(ctx->Array.TexCoordStride[texSet]);
  949.          break;
  950.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  951.          *params = INT_TO_BOOL(0);
  952.          break;
  953.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  954.          *params = INT_TO_BOOL(ctx->Array.EdgeFlagStride);
  955.          break;
  956.       case GL_EDGE_FLAG_ARRAY_EXT:
  957.          *params = INT_TO_BOOL(0);
  958.          break;
  959.  
  960.       /* GL_SGIS_multitexture */
  961.       case GL_SELECTED_TEXTURE_SGIS:
  962.          *params = INT_TO_BOOL(ctx->Texture.CurrentSet);
  963.          break;
  964.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  965.          *params = INT_TO_BOOL(ctx->TexCoordSet);
  966.          break;
  967.       case GL_MAX_TEXTURES_SGIS:
  968.          *params = INT_TO_BOOL(max_textures(ctx));
  969.          break;
  970.  
  971.       /* GL_EXT_multitexture */
  972.       case GL_SELECTED_TEXTURE_EXT:
  973.          *params = INT_TO_BOOL(ctx->Texture.CurrentSet);
  974.          break;
  975.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  976.          *params = INT_TO_BOOL(ctx->TexCoordSet);
  977.          break;
  978.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  979.          *params = INT_TO_BOOL(ctx->Texture.CurrentTransformSet);
  980.          break;
  981.       case GL_MAX_TEXTURES_EXT:
  982.          *params = INT_TO_BOOL(max_textures(ctx));
  983.          break;
  984.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  985.          *params = INT_TO_BOOL(MAX_TEX_COORD_SETS);
  986.          break;
  987.  
  988.       default:
  989.          gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
  990.    }
  991. }
  992.  
  993.  
  994.  
  995.  
  996. void gl_GetDoublev( GLcontext *ctx, GLenum pname, GLdouble *params )
  997. {
  998.    GLuint i;
  999.    GLuint texSet = ctx->Texture.CurrentSet;
  1000.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  1001.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  1002.  
  1003.    if (INSIDE_BEGIN_END(ctx)) {
  1004.       gl_error( ctx, GL_INVALID_OPERATION, "glGetDoublev" );
  1005.       return;
  1006.    }
  1007.  
  1008.    switch (pname) {
  1009.       case GL_ACCUM_RED_BITS:
  1010.       case GL_ACCUM_GREEN_BITS:
  1011.       case GL_ACCUM_BLUE_BITS:
  1012.       case GL_ACCUM_ALPHA_BITS:
  1013.          *params = (GLdouble) ctx->Visual->AccumBits;
  1014.          break;
  1015.       case GL_ACCUM_CLEAR_VALUE:
  1016.          params[0] = (GLdouble) ctx->Accum.ClearColor[0];
  1017.          params[1] = (GLdouble) ctx->Accum.ClearColor[1];
  1018.          params[2] = (GLdouble) ctx->Accum.ClearColor[2];
  1019.          params[3] = (GLdouble) ctx->Accum.ClearColor[3];
  1020.          break;
  1021.       case GL_ALPHA_BIAS:
  1022.          *params = (GLdouble) ctx->Pixel.AlphaBias;
  1023.          break;
  1024.       case GL_ALPHA_BITS:
  1025.          *params = (GLdouble) ctx->Visual->AlphaBits;
  1026.          break;
  1027.       case GL_ALPHA_SCALE:
  1028.          *params = (GLdouble) ctx->Pixel.AlphaScale;
  1029.          break;
  1030.       case GL_ALPHA_TEST:
  1031.          *params = (GLdouble) ctx->Color.AlphaEnabled;
  1032.          break;
  1033.       case GL_ALPHA_TEST_FUNC:
  1034.          *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
  1035.          break;
  1036.       case GL_ALPHA_TEST_REF:
  1037.          *params = (GLdouble) ctx->Color.AlphaRef / 255.0;
  1038.          break;
  1039.       case GL_ATTRIB_STACK_DEPTH:
  1040.          *params = (GLdouble ) (ctx->AttribStackDepth);
  1041.          break;
  1042.       case GL_AUTO_NORMAL:
  1043.          *params = (GLdouble) ctx->Eval.AutoNormal;
  1044.          break;
  1045.       case GL_AUX_BUFFERS:
  1046.          *params = (GLdouble) NUM_AUX_BUFFERS;
  1047.          break;
  1048.       case GL_BLEND:
  1049.          *params = (GLdouble) ctx->Color.BlendEnabled;
  1050.          break;
  1051.       case GL_BLEND_DST:
  1052.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendDst);
  1053.          break;
  1054.       case GL_BLEND_SRC:
  1055.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrc);
  1056.          break;
  1057.       case GL_BLEND_EQUATION_EXT:
  1058.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation);
  1059.          break;
  1060.       case GL_BLEND_COLOR_EXT:
  1061.          params[0] = (GLdouble) ctx->Color.BlendColor[0];
  1062.          params[1] = (GLdouble) ctx->Color.BlendColor[1];
  1063.          params[2] = (GLdouble) ctx->Color.BlendColor[2];
  1064.          params[3] = (GLdouble) ctx->Color.BlendColor[3];
  1065.          break;
  1066.       case GL_BLUE_BIAS:
  1067.          *params = (GLdouble) ctx->Pixel.BlueBias;
  1068.          break;
  1069.       case GL_BLUE_BITS:
  1070.          *params = (GLdouble) ctx->Visual->BlueBits;
  1071.          break;
  1072.       case GL_BLUE_SCALE:
  1073.          *params = (GLdouble) ctx->Pixel.BlueScale;
  1074.          break;
  1075.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  1076.          *params = (GLdouble) (ctx->ClientAttribStackDepth);
  1077.          break;
  1078.       case GL_CLIP_PLANE0:
  1079.       case GL_CLIP_PLANE1:
  1080.       case GL_CLIP_PLANE2:
  1081.       case GL_CLIP_PLANE3:
  1082.       case GL_CLIP_PLANE4:
  1083.       case GL_CLIP_PLANE5:
  1084.          *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1085.          break;
  1086.       case GL_COLOR_CLEAR_VALUE:
  1087.          params[0] = (GLdouble) ctx->Color.ClearColor[0];
  1088.          params[1] = (GLdouble) ctx->Color.ClearColor[1];
  1089.          params[2] = (GLdouble) ctx->Color.ClearColor[2];
  1090.          params[3] = (GLdouble) ctx->Color.ClearColor[3];
  1091.          break;
  1092.       case GL_COLOR_MATERIAL:
  1093.          *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
  1094.          break;
  1095.       case GL_COLOR_MATERIAL_FACE:
  1096.          *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
  1097.          break;
  1098.       case GL_COLOR_MATERIAL_PARAMETER:
  1099.          *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
  1100.          break;
  1101.       case GL_COLOR_WRITEMASK:
  1102.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0;
  1103.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0;
  1104.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0;
  1105.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0;
  1106.          break;
  1107.       case GL_CULL_FACE:
  1108.          *params = (GLdouble) ctx->Polygon.CullFlag;
  1109.          break;
  1110.       case GL_CULL_FACE_MODE:
  1111.          *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
  1112.          break;
  1113.       case GL_CURRENT_COLOR:
  1114.          params[0] = (GLfloat) ctx->Current.ByteColor[0] / 255.0F;
  1115.          params[1] = (GLfloat) ctx->Current.ByteColor[1] / 255.0F;
  1116.          params[2] = (GLfloat) ctx->Current.ByteColor[2] / 255.0F;
  1117.          params[3] = (GLfloat) ctx->Current.ByteColor[3] / 255.0F;
  1118.          break;
  1119.       case GL_CURRENT_INDEX:
  1120.          *params = (GLdouble) ctx->Current.Index;
  1121.          break;
  1122.       case GL_CURRENT_NORMAL:
  1123.          params[0] = (GLdouble) ctx->Current.Normal[0];
  1124.          params[1] = (GLdouble) ctx->Current.Normal[1];
  1125.          params[2] = (GLdouble) ctx->Current.Normal[2];
  1126.          break;
  1127.       case GL_CURRENT_RASTER_COLOR:
  1128.          params[0] = (GLdouble) ctx->Current.RasterColor[0];
  1129.          params[1] = (GLdouble) ctx->Current.RasterColor[1];
  1130.          params[2] = (GLdouble) ctx->Current.RasterColor[2];
  1131.          params[3] = (GLdouble) ctx->Current.RasterColor[3];
  1132.          break;
  1133.       case GL_CURRENT_RASTER_DISTANCE:
  1134.          params[0] = (GLdouble) ctx->Current.RasterDistance;
  1135.          break;
  1136.       case GL_CURRENT_RASTER_INDEX:
  1137.          *params = (GLdouble) ctx->Current.RasterIndex;
  1138.          break;
  1139.       case GL_CURRENT_RASTER_POSITION:
  1140.          params[0] = (GLdouble) ctx->Current.RasterPos[0];
  1141.          params[1] = (GLdouble) ctx->Current.RasterPos[1];
  1142.          params[2] = (GLdouble) ctx->Current.RasterPos[2];
  1143.          params[3] = (GLdouble) ctx->Current.RasterPos[3];
  1144.          break;
  1145.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  1146.          params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][0];
  1147.          params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][1];
  1148.          params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][2];
  1149.          params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformSet][3];
  1150.          break;
  1151.       case GL_CURRENT_RASTER_POSITION_VALID:
  1152.          *params = (GLdouble) ctx->Current.RasterPosValid;
  1153.          break;
  1154.       case GL_CURRENT_TEXTURE_COORDS:
  1155.          params[0] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][0];
  1156.          params[1] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][1];
  1157.          params[2] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][2];
  1158.          params[3] = (GLdouble) ctx->Current.MultiTexCoord[texTransformSet][3];
  1159.          break;
  1160.       case GL_DEPTH_BIAS:
  1161.          *params = (GLdouble) ctx->Pixel.DepthBias;
  1162.          break;
  1163.       case GL_DEPTH_BITS:
  1164.          *params = (GLdouble) ctx->Visual->DepthBits;
  1165.          break;
  1166.       case GL_DEPTH_CLEAR_VALUE:
  1167.          *params = (GLdouble) ctx->Depth.Clear;
  1168.          break;
  1169.       case GL_DEPTH_FUNC:
  1170.          *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
  1171.          break;
  1172.       case GL_DEPTH_RANGE:
  1173.          params[0] = (GLdouble) ctx->Viewport.Near;
  1174.          params[1] = (GLdouble) ctx->Viewport.Far;
  1175.          break;
  1176.       case GL_DEPTH_SCALE:
  1177.          *params = (GLdouble) ctx->Pixel.DepthScale;
  1178.          break;
  1179.       case GL_DEPTH_TEST:
  1180.          *params = (GLdouble) ctx->Depth.Test;
  1181.          break;
  1182.       case GL_DEPTH_WRITEMASK:
  1183.          *params = (GLdouble) ctx->Depth.Mask;
  1184.          break;
  1185.       case GL_DITHER:
  1186.          *params = (GLdouble) ctx->Color.DitherFlag;
  1187.          break;
  1188.       case GL_DOUBLEBUFFER:
  1189.          *params = (GLdouble) ctx->Visual->DBflag;
  1190.          break;
  1191.       case GL_DRAW_BUFFER:
  1192.          *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
  1193.          break;
  1194.       case GL_EDGE_FLAG:
  1195.          *params = (GLdouble) ctx->Current.EdgeFlag;
  1196.          break;
  1197.       case GL_FEEDBACK_BUFFER_SIZE:
  1198.          /* TODO: is this right?  Or, return number of entries in buffer? */
  1199.          *params = (GLdouble) ctx->Feedback.BufferSize;
  1200.          break;
  1201.       case GL_FEEDBACK_BUFFER_TYPE:
  1202.          *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
  1203.          break;
  1204.       case GL_FOG:
  1205.          *params = (GLdouble) ctx->Fog.Enabled;
  1206.          break;
  1207.       case GL_FOG_COLOR:
  1208.          params[0] = (GLdouble) ctx->Fog.Color[0];
  1209.          params[1] = (GLdouble) ctx->Fog.Color[1];
  1210.          params[2] = (GLdouble) ctx->Fog.Color[2];
  1211.          params[3] = (GLdouble) ctx->Fog.Color[3];
  1212.          break;
  1213.       case GL_FOG_DENSITY:
  1214.          *params = (GLdouble) ctx->Fog.Density;
  1215.          break;
  1216.       case GL_FOG_END:
  1217.          *params = (GLdouble) ctx->Fog.End;
  1218.          break;
  1219.       case GL_FOG_HINT:
  1220.          *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
  1221.          break;
  1222.       case GL_FOG_INDEX:
  1223.          *params = (GLdouble) ctx->Fog.Index;
  1224.          break;
  1225.       case GL_FOG_MODE:
  1226.          *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
  1227.          break;
  1228.       case GL_FOG_START:
  1229.          *params = (GLdouble) ctx->Fog.Start;
  1230.          break;
  1231.       case GL_FRONT_FACE:
  1232.          *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
  1233.          break;
  1234.       case GL_GREEN_BIAS:
  1235.          *params = (GLdouble) ctx->Pixel.GreenBias;
  1236.          break;
  1237.       case GL_GREEN_BITS:
  1238.          *params = (GLdouble) ctx->Visual->GreenBits;
  1239.          break;
  1240.       case GL_GREEN_SCALE:
  1241.          *params = (GLdouble) ctx->Pixel.GreenScale;
  1242.          break;
  1243.       case GL_INDEX_BITS:
  1244.          *params = (GLdouble) ctx->Visual->IndexBits;
  1245.          break;
  1246.       case GL_INDEX_CLEAR_VALUE:
  1247.          *params = (GLdouble) ctx->Color.ClearIndex;
  1248.          break;
  1249.       case GL_INDEX_MODE:
  1250.          *params = ctx->Visual->RGBAflag ? 0.0 : 1.0;
  1251.          break;
  1252.       case GL_INDEX_OFFSET:
  1253.          *params = (GLdouble) ctx->Pixel.IndexOffset;
  1254.          break;
  1255.       case GL_INDEX_SHIFT:
  1256.          *params = (GLdouble) ctx->Pixel.IndexShift;
  1257.          break;
  1258.       case GL_INDEX_WRITEMASK:
  1259.          *params = (GLdouble) ctx->Color.IndexMask;
  1260.          break;
  1261.       case GL_LIGHT0:
  1262.       case GL_LIGHT1:
  1263.       case GL_LIGHT2:
  1264.       case GL_LIGHT3:
  1265.       case GL_LIGHT4:
  1266.       case GL_LIGHT5:
  1267.       case GL_LIGHT6:
  1268.       case GL_LIGHT7:
  1269.          *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  1270.          break;
  1271.       case GL_LIGHTING:
  1272.          *params = (GLdouble) ctx->Light.Enabled;
  1273.          break;
  1274.       case GL_LIGHT_MODEL_AMBIENT:
  1275.          params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
  1276.          params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
  1277.          params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
  1278.          params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
  1279.          break;
  1280.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  1281.          params[0] = (GLdouble) ctx->Light.Model.ColorControl;
  1282.          break;
  1283.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1284.          *params = (GLdouble) ctx->Light.Model.LocalViewer;
  1285.          break;
  1286.       case GL_LIGHT_MODEL_TWO_SIDE:
  1287.          *params = (GLdouble) ctx->Light.Model.TwoSide;
  1288.          break;
  1289.       case GL_LINE_SMOOTH:
  1290.          *params = (GLdouble) ctx->Line.SmoothFlag;
  1291.          break;
  1292.       case GL_LINE_SMOOTH_HINT:
  1293.          *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
  1294.          break;
  1295.       case GL_LINE_STIPPLE:
  1296.          *params = (GLdouble) ctx->Line.StippleFlag;
  1297.          break;
  1298.       case GL_LINE_STIPPLE_PATTERN:
  1299.          *params = (GLdouble) ctx->Line.StipplePattern;
  1300.          break;
  1301.       case GL_LINE_STIPPLE_REPEAT:
  1302.          *params = (GLdouble) ctx->Line.StippleFactor;
  1303.          break;
  1304.       case GL_LINE_WIDTH:
  1305.          *params = (GLdouble) ctx->Line.Width;
  1306.          break;
  1307.       case GL_LINE_WIDTH_GRANULARITY:
  1308.          *params = (GLdouble) LINE_WIDTH_GRANULARITY;
  1309.          break;
  1310.       case GL_LINE_WIDTH_RANGE:
  1311.          params[0] = (GLdouble) MIN_LINE_WIDTH;
  1312.          params[1] = (GLdouble) MAX_LINE_WIDTH;
  1313.          break;
  1314.       case GL_LIST_BASE:
  1315.          *params = (GLdouble) ctx->List.ListBase;
  1316.          break;
  1317.       case GL_LIST_INDEX:
  1318.          *params = (GLdouble) ctx->CurrentListNum;
  1319.          break;
  1320.       case GL_LIST_MODE:
  1321.          *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
  1322.                                   : ENUM_TO_DOUBLE(GL_COMPILE);
  1323.          break;
  1324.       case GL_INDEX_LOGIC_OP:
  1325.          *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
  1326.          break;
  1327.       case GL_COLOR_LOGIC_OP:
  1328.          *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
  1329.          break;
  1330.       case GL_LOGIC_OP_MODE:
  1331.          *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
  1332.          break;
  1333.       case GL_MAP1_COLOR_4:
  1334.          *params = (GLdouble) ctx->Eval.Map1Color4;
  1335.          break;
  1336.       case GL_MAP1_GRID_DOMAIN:
  1337.          params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
  1338.          params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
  1339.          break;
  1340.       case GL_MAP1_GRID_SEGMENTS:
  1341.          *params = (GLdouble) ctx->Eval.MapGrid1un;
  1342.          break;
  1343.       case GL_MAP1_INDEX:
  1344.          *params = (GLdouble) ctx->Eval.Map1Index;
  1345.          break;
  1346.       case GL_MAP1_NORMAL:
  1347.          *params = (GLdouble) ctx->Eval.Map1Normal;
  1348.          break;
  1349.       case GL_MAP1_TEXTURE_COORD_1:
  1350.          *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
  1351.          break;
  1352.       case GL_MAP1_TEXTURE_COORD_2:
  1353.          *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
  1354.          break;
  1355.       case GL_MAP1_TEXTURE_COORD_3:
  1356.          *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
  1357.          break;
  1358.       case GL_MAP1_TEXTURE_COORD_4:
  1359.          *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
  1360.          break;
  1361.       case GL_MAP1_VERTEX_3:
  1362.          *params = (GLdouble) ctx->Eval.Map1Vertex3;
  1363.          break;
  1364.       case GL_MAP1_VERTEX_4:
  1365.          *params = (GLdouble) ctx->Eval.Map1Vertex4;
  1366.          break;
  1367.       case GL_MAP2_COLOR_4:
  1368.          *params = (GLdouble) ctx->Eval.Map2Color4;
  1369.          break;
  1370.       case GL_MAP2_GRID_DOMAIN:
  1371.          params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
  1372.          params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
  1373.          params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
  1374.          params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
  1375.          break;
  1376.       case GL_MAP2_GRID_SEGMENTS:
  1377.          params[0] = (GLdouble) ctx->Eval.MapGrid2un;
  1378.          params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
  1379.          break;
  1380.       case GL_MAP2_INDEX:
  1381.          *params = (GLdouble) ctx->Eval.Map2Index;
  1382.          break;
  1383.       case GL_MAP2_NORMAL:
  1384.          *params = (GLdouble) ctx->Eval.Map2Normal;
  1385.          break;
  1386.       case GL_MAP2_TEXTURE_COORD_1:
  1387.          *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
  1388.          break;
  1389.       case GL_MAP2_TEXTURE_COORD_2:
  1390.          *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
  1391.          break;
  1392.       case GL_MAP2_TEXTURE_COORD_3:
  1393.          *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
  1394.          break;
  1395.       case GL_MAP2_TEXTURE_COORD_4:
  1396.          *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
  1397.          break;
  1398.       case GL_MAP2_VERTEX_3:
  1399.          *params = (GLdouble) ctx->Eval.Map2Vertex3;
  1400.          break;
  1401.       case GL_MAP2_VERTEX_4:
  1402.          *params = (GLdouble) ctx->Eval.Map2Vertex4;
  1403.          break;
  1404.       case GL_MAP_COLOR:
  1405.          *params = (GLdouble) ctx->Pixel.MapColorFlag;
  1406.          break;
  1407.       case GL_MAP_STENCIL:
  1408.          *params = (GLdouble) ctx->Pixel.MapStencilFlag;
  1409.          break;
  1410.       case GL_MATRIX_MODE:
  1411.          *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
  1412.          break;
  1413.       case GL_MAX_ATTRIB_STACK_DEPTH:
  1414.          *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
  1415.          break;
  1416.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  1417.          *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  1418.          break;
  1419.       case GL_MAX_CLIP_PLANES:
  1420.          *params = (GLdouble) MAX_CLIP_PLANES;
  1421.          break;
  1422.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  1423.          *params = (GLdouble) VB_MAX;
  1424.          break;
  1425.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  1426.          *params = (GLdouble) VB_MAX;
  1427.          break;
  1428.       case GL_MAX_EVAL_ORDER:
  1429.          *params = (GLdouble) MAX_EVAL_ORDER;
  1430.          break;
  1431.       case GL_MAX_LIGHTS:
  1432.          *params = (GLdouble) MAX_LIGHTS;
  1433.          break;
  1434.       case GL_MAX_LIST_NESTING:
  1435.          *params = (GLdouble) MAX_LIST_NESTING;
  1436.          break;
  1437.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  1438.          *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
  1439.          break;
  1440.       case GL_MAX_NAME_STACK_DEPTH:
  1441.          *params = (GLdouble) MAX_NAME_STACK_DEPTH;
  1442.          break;
  1443.       case GL_MAX_PIXEL_MAP_TABLE:
  1444.          *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
  1445.          break;
  1446.       case GL_MAX_PROJECTION_STACK_DEPTH:
  1447.          *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
  1448.          break;
  1449.       case GL_MAX_TEXTURE_SIZE:
  1450.          *params = (GLdouble) max_texture_size(ctx);
  1451.          break;
  1452.       case GL_MAX_TEXTURE_STACK_DEPTH:
  1453.          *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
  1454.          break;
  1455.       case GL_MAX_VIEWPORT_DIMS:
  1456.          params[0] = (GLdouble) MAX_WIDTH;
  1457.          params[1] = (GLdouble) MAX_HEIGHT;
  1458.          break;
  1459.       case GL_MODELVIEW_MATRIX:
  1460.          for (i=0;i<16;i++) {
  1461.             params[i] = (GLdouble) ctx->ModelViewMatrix[i];
  1462.          }
  1463.          break;
  1464.       case GL_MODELVIEW_STACK_DEPTH:
  1465.          *params = (GLdouble) (ctx->ModelViewStackDepth + 1);
  1466.          break;
  1467.       case GL_NAME_STACK_DEPTH:
  1468.          *params = (GLdouble) ctx->Select.NameStackDepth;
  1469.          break;
  1470.       case GL_NORMALIZE:
  1471.          *params = (GLdouble) ctx->Transform.Normalize;
  1472.          break;
  1473.       case GL_PACK_ALIGNMENT:
  1474.          *params = (GLdouble) ctx->Pack.Alignment;
  1475.          break;
  1476.       case GL_PACK_LSB_FIRST:
  1477.          *params = (GLdouble) ctx->Pack.LsbFirst;
  1478.          break;
  1479.       case GL_PACK_ROW_LENGTH:
  1480.          *params = (GLdouble) ctx->Pack.RowLength;
  1481.          break;
  1482.       case GL_PACK_SKIP_PIXELS:
  1483.          *params = (GLdouble) ctx->Pack.SkipPixels;
  1484.          break;
  1485.       case GL_PACK_SKIP_ROWS:
  1486.          *params = (GLdouble) ctx->Pack.SkipRows;
  1487.          break;
  1488.       case GL_PACK_SWAP_BYTES:
  1489.          *params = (GLdouble) ctx->Pack.SwapBytes;
  1490.          break;
  1491.       case GL_PACK_SKIP_IMAGES_EXT:
  1492.          *params = (GLdouble) ctx->Pack.SkipImages;
  1493.          break;
  1494.       case GL_PACK_IMAGE_HEIGHT_EXT:
  1495.          *params = (GLdouble) ctx->Pack.ImageHeight;
  1496.          break;
  1497.       case GL_PERSPECTIVE_CORRECTION_HINT:
  1498.          *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
  1499.          break;
  1500.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  1501.          *params = (GLdouble) ctx->Pixel.MapAtoAsize;
  1502.          break;
  1503.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  1504.          *params = (GLdouble) ctx->Pixel.MapBtoBsize;
  1505.          break;
  1506.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  1507.          *params = (GLdouble) ctx->Pixel.MapGtoGsize;
  1508.          break;
  1509.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  1510.          *params = (GLdouble) ctx->Pixel.MapItoAsize;
  1511.          break;
  1512.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  1513.          *params = (GLdouble) ctx->Pixel.MapItoBsize;
  1514.          break;
  1515.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  1516.          *params = (GLdouble) ctx->Pixel.MapItoGsize;
  1517.          break;
  1518.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  1519.          *params = (GLdouble) ctx->Pixel.MapItoIsize;
  1520.          break;
  1521.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  1522.          *params = (GLdouble) ctx->Pixel.MapItoRsize;
  1523.          break;
  1524.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  1525.          *params = (GLdouble) ctx->Pixel.MapRtoRsize;
  1526.          break;
  1527.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  1528.          *params = (GLdouble) ctx->Pixel.MapStoSsize;
  1529.          break;
  1530.       case GL_POINT_SIZE:
  1531.          *params = (GLdouble) ctx->Point.Size;
  1532.          break;
  1533.       case GL_POINT_SIZE_GRANULARITY:
  1534.          *params = (GLdouble) POINT_SIZE_GRANULARITY;
  1535.          break;
  1536.       case GL_POINT_SIZE_RANGE:
  1537.          params[0] = (GLdouble) MIN_POINT_SIZE;
  1538.          params[1] = (GLdouble) MAX_POINT_SIZE;
  1539.          break;
  1540.       case GL_POINT_SMOOTH:
  1541.          *params = (GLdouble) ctx->Point.SmoothFlag;
  1542.          break;
  1543.       case GL_POINT_SMOOTH_HINT:
  1544.          *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
  1545.          break;
  1546.       case GL_POINT_SIZE_MIN_EXT:
  1547.          *params = (GLdouble) (ctx->Point.MinSize);
  1548.          break;
  1549.       case GL_POINT_SIZE_MAX_EXT:
  1550.          *params = (GLdouble) (ctx->Point.MaxSize);
  1551.          break;
  1552.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  1553.          *params = (GLdouble) (ctx->Point.Threshold);
  1554.          break;
  1555.       case GL_DISTANCE_ATTENUATION_EXT:
  1556.          params[0] = (GLdouble) (ctx->Point.Params[0]);
  1557.          params[1] = (GLdouble) (ctx->Point.Params[1]);
  1558.          params[2] = (GLdouble) (ctx->Point.Params[2]);
  1559.          break;
  1560.       case GL_POLYGON_MODE:
  1561.          params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
  1562.          params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
  1563.          break;
  1564. #ifdef GL_EXT_polygon_offset
  1565.       case GL_POLYGON_OFFSET_BIAS_EXT:
  1566.          *params = (GLdouble) ctx->Polygon.OffsetUnits;
  1567.          break;
  1568. #endif
  1569.       case GL_POLYGON_OFFSET_FACTOR:
  1570.          *params = (GLdouble) ctx->Polygon.OffsetFactor;
  1571.          break;
  1572.       case GL_POLYGON_OFFSET_UNITS:
  1573.          *params = (GLdouble) ctx->Polygon.OffsetUnits;
  1574.          break;
  1575.       case GL_POLYGON_SMOOTH:
  1576.          *params = (GLdouble) ctx->Polygon.SmoothFlag;
  1577.          break;
  1578.       case GL_POLYGON_SMOOTH_HINT:
  1579.          *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
  1580.          break;
  1581.       case GL_POLYGON_STIPPLE:
  1582.          *params = (GLdouble) ctx->Polygon.StippleFlag;
  1583.          break;
  1584.       case GL_PROJECTION_MATRIX:
  1585.          for (i=0;i<16;i++) {
  1586.             params[i] = (GLdouble) ctx->ProjectionMatrix[i];
  1587.          }
  1588.          break;
  1589.       case GL_PROJECTION_STACK_DEPTH:
  1590.          *params = (GLdouble) (ctx->ProjectionStackDepth + 1);
  1591.          break;
  1592.       case GL_READ_BUFFER:
  1593.          *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
  1594.          break;
  1595.       case GL_RED_BIAS:
  1596.          *params = (GLdouble) ctx->Pixel.RedBias;
  1597.          break;
  1598.       case GL_RED_BITS:
  1599.          *params = (GLdouble) ctx->Visual->RedBits;
  1600.          break;
  1601.       case GL_RED_SCALE:
  1602.          *params = (GLdouble) ctx->Pixel.RedScale;
  1603.          break;
  1604.       case GL_RENDER_MODE:
  1605.          *params = ENUM_TO_DOUBLE(ctx->RenderMode);
  1606.          break;
  1607.       case GL_RGBA_MODE:
  1608.          *params = (GLdouble) ctx->Visual->RGBAflag;
  1609.          break;
  1610.       case GL_SCISSOR_BOX:
  1611.          params[0] = (GLdouble) ctx->Scissor.X;
  1612.          params[1] = (GLdouble) ctx->Scissor.Y;
  1613.          params[2] = (GLdouble) ctx->Scissor.Width;
  1614.          params[3] = (GLdouble) ctx->Scissor.Height;
  1615.          break;
  1616.       case GL_SCISSOR_TEST:
  1617.          *params = (GLdouble) ctx->Scissor.Enabled;
  1618.          break;
  1619.       case GL_SELECTION_BUFFER_SIZE:
  1620.          *params = (GLdouble) ctx->Select.BufferSize;
  1621.          break;
  1622.       case GL_SHADE_MODEL:
  1623.          *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
  1624.          break;
  1625.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  1626.          *params = (GLdouble) ctx->Texture.SharedPalette;
  1627.          break;
  1628.       case GL_STENCIL_BITS:
  1629.          *params = (GLdouble) ctx->Visual->StencilBits;
  1630.          break;
  1631.       case GL_STENCIL_CLEAR_VALUE:
  1632.          *params = (GLdouble) ctx->Stencil.Clear;
  1633.          break;
  1634.       case GL_STENCIL_FAIL:
  1635.          *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
  1636.          break;
  1637.       case GL_STENCIL_FUNC:
  1638.          *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
  1639.          break;
  1640.       case GL_STENCIL_PASS_DEPTH_FAIL:
  1641.          *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
  1642.          break;
  1643.       case GL_STENCIL_PASS_DEPTH_PASS:
  1644.          *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
  1645.          break;
  1646.       case GL_STENCIL_REF:
  1647.          *params = (GLdouble) ctx->Stencil.Ref;
  1648.          break;
  1649.       case GL_STENCIL_TEST:
  1650.          *params = (GLdouble) ctx->Stencil.Enabled;
  1651.          break;
  1652.       case GL_STENCIL_VALUE_MASK:
  1653.          *params = (GLdouble) ctx->Stencil.ValueMask;
  1654.          break;
  1655.       case GL_STENCIL_WRITEMASK:
  1656.          *params = (GLdouble) ctx->Stencil.WriteMask;
  1657.          break;
  1658.       case GL_STEREO:
  1659.          *params = 0.0;   /* TODO */
  1660.          break;
  1661.       case GL_SUBPIXEL_BITS:
  1662.          *params = 0.0;   /* TODO */
  1663.          break;
  1664.       case GL_TEXTURE_1D:
  1665.          {
  1666.             GLuint bit = TEXTURE0_1D << (texSet * 4);
  1667.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  1668.          }
  1669.          break;
  1670.       case GL_TEXTURE_2D:
  1671.          {
  1672.             GLuint bit = TEXTURE0_2D << (texSet * 4);
  1673.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  1674.          }
  1675.          break;
  1676.       case GL_TEXTURE_3D:
  1677.          {
  1678.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  1679.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  1680.          }
  1681.          break;
  1682.       case GL_TEXTURE_BINDING_1D:
  1683.          *params = (GLdouble) textureSet->Current1D->Name;
  1684.           break;
  1685.       case GL_TEXTURE_BINDING_2D:
  1686.          *params = (GLdouble) textureSet->Current2D->Name;
  1687.           break;
  1688.       case GL_TEXTURE_BINDING_3D:
  1689.          *params = (GLdouble) textureSet->Current3D->Name;
  1690.           break;
  1691.       case GL_TEXTURE_ENV_COLOR:
  1692.          params[0] = (GLdouble) textureSet->EnvColor[0];
  1693.          params[1] = (GLdouble) textureSet->EnvColor[1];
  1694.          params[2] = (GLdouble) textureSet->EnvColor[2];
  1695.          params[3] = (GLdouble) textureSet->EnvColor[3];
  1696.          break;
  1697.       case GL_TEXTURE_ENV_MODE:
  1698.          *params = ENUM_TO_DOUBLE(textureSet->EnvMode);
  1699.          break;
  1700.       case GL_TEXTURE_GEN_S:
  1701.          *params = (textureSet->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  1702.          break;
  1703.       case GL_TEXTURE_GEN_T:
  1704.          *params = (textureSet->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  1705.          break;
  1706.       case GL_TEXTURE_GEN_R:
  1707.          *params = (textureSet->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  1708.          break;
  1709.       case GL_TEXTURE_GEN_Q:
  1710.          *params = (textureSet->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  1711.          break;
  1712.       case GL_TEXTURE_MATRIX:
  1713.          for (i=0;i<16;i++) {
  1714.             params[i] = (GLdouble) ctx->TextureMatrix[texTransformSet][i];
  1715.          }
  1716.          break;
  1717.       case GL_TEXTURE_STACK_DEPTH:
  1718.          *params = (GLdouble) (ctx->TextureStackDepth[texTransformSet] + 1);
  1719.          break;
  1720.       case GL_UNPACK_ALIGNMENT:
  1721.          *params = (GLdouble) ctx->Unpack.Alignment;
  1722.          break;
  1723.       case GL_UNPACK_LSB_FIRST:
  1724.          *params = (GLdouble) ctx->Unpack.LsbFirst;
  1725.          break;
  1726.       case GL_UNPACK_ROW_LENGTH:
  1727.          *params = (GLdouble) ctx->Unpack.RowLength;
  1728.          break;
  1729.       case GL_UNPACK_SKIP_PIXELS:
  1730.          *params = (GLdouble) ctx->Unpack.SkipPixels;
  1731.          break;
  1732.       case GL_UNPACK_SKIP_ROWS:
  1733.          *params = (GLdouble) ctx->Unpack.SkipRows;
  1734.          break;
  1735.       case GL_UNPACK_SWAP_BYTES:
  1736.          *params = (GLdouble) ctx->Unpack.SwapBytes;
  1737.          break;
  1738.       case GL_UNPACK_SKIP_IMAGES_EXT:
  1739.          *params = (GLdouble) ctx->Unpack.SkipImages;
  1740.          break;
  1741.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  1742.          *params = (GLdouble) ctx->Unpack.ImageHeight;
  1743.          break;
  1744.       case GL_VIEWPORT:
  1745.          params[0] = (GLdouble) ctx->Viewport.X;
  1746.          params[1] = (GLdouble) ctx->Viewport.Y;
  1747.          params[2] = (GLdouble) ctx->Viewport.Width;
  1748.          params[3] = (GLdouble) ctx->Viewport.Height;
  1749.          break;
  1750.       case GL_ZOOM_X:
  1751.          *params = (GLdouble) ctx->Pixel.ZoomX;
  1752.          break;
  1753.       case GL_ZOOM_Y:
  1754.          *params = (GLdouble) ctx->Pixel.ZoomY;
  1755.          break;
  1756.       case GL_VERTEX_ARRAY_SIZE:
  1757.          *params = (GLdouble) ctx->Array.VertexSize;
  1758.          break;
  1759.       case GL_VERTEX_ARRAY_TYPE:
  1760.          *params = ENUM_TO_DOUBLE(ctx->Array.VertexType);
  1761.          break;
  1762.       case GL_VERTEX_ARRAY_STRIDE:
  1763.          *params = (GLdouble) ctx->Array.VertexStride;
  1764.          break;
  1765.       case GL_VERTEX_ARRAY_COUNT_EXT:
  1766.          *params = 0.0;
  1767.          break;
  1768.       case GL_NORMAL_ARRAY_TYPE:
  1769.          *params = ENUM_TO_DOUBLE(ctx->Array.NormalType);
  1770.          break;
  1771.       case GL_NORMAL_ARRAY_STRIDE:
  1772.          *params = (GLdouble) ctx->Array.NormalStride;
  1773.          break;
  1774.       case GL_NORMAL_ARRAY_COUNT_EXT:
  1775.          *params = 0.0;
  1776.          break;
  1777.       case GL_COLOR_ARRAY_SIZE:
  1778.          *params = (GLdouble) ctx->Array.ColorSize;
  1779.          break;
  1780.       case GL_COLOR_ARRAY_TYPE:
  1781.          *params = ENUM_TO_DOUBLE(ctx->Array.ColorType);
  1782.          break;
  1783.       case GL_COLOR_ARRAY_STRIDE:
  1784.          *params = (GLdouble) ctx->Array.ColorStride;
  1785.          break;
  1786.       case GL_COLOR_ARRAY_COUNT_EXT:
  1787.          *params = 0.0;
  1788.          break;
  1789.       case GL_INDEX_ARRAY_TYPE:
  1790.          *params = ENUM_TO_DOUBLE(ctx->Array.IndexType);
  1791.          break;
  1792.       case GL_INDEX_ARRAY_STRIDE:
  1793.          *params = (GLdouble) ctx->Array.IndexStride;
  1794.          break;
  1795.       case GL_INDEX_ARRAY_COUNT_EXT:
  1796.          *params = 0.0;
  1797.          break;
  1798.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  1799.          *params = (GLdouble) ctx->Array.TexCoordSize[texSet];
  1800.          break;
  1801.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  1802.          *params = ENUM_TO_DOUBLE(ctx->Array.TexCoordType[texSet]);
  1803.          break;
  1804.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  1805.          *params = (GLdouble) ctx->Array.TexCoordStride[texSet];
  1806.          break;
  1807.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  1808.          *params = 0.0;
  1809.          break;
  1810.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  1811.          *params = (GLdouble) ctx->Array.EdgeFlagStride;
  1812.          break;
  1813.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  1814.          *params = 0.0;
  1815.          break;
  1816.  
  1817.       /* GL_SIGS_multitexture */
  1818.       case GL_SELECTED_TEXTURE_SGIS:
  1819.          *params = (GLdouble) ctx->Texture.CurrentSet;
  1820.          break;
  1821.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  1822.          *params = (GLdouble) ctx->TexCoordSet;
  1823.          break;
  1824.       case GL_MAX_TEXTURES_SGIS:
  1825.          *params = (GLdouble) max_textures(ctx);
  1826.          break;
  1827.  
  1828.       /* GL_EXT_multitexture */
  1829.       case GL_SELECTED_TEXTURE_EXT:
  1830.          *params = (GLdouble) ctx->Texture.CurrentSet;
  1831.          break;
  1832.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  1833.          *params = (GLdouble) ctx->TexCoordSet;
  1834.          break;
  1835.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  1836.          *params = (GLdouble) ctx->Texture.CurrentTransformSet;
  1837.          break;
  1838.       case GL_MAX_TEXTURES_EXT:
  1839.          *params = (GLdouble) max_textures(ctx);
  1840.          break;
  1841.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  1842.          *params = (GLdouble) MAX_TEX_COORD_SETS;
  1843.          break;
  1844.  
  1845.       default:
  1846.          gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
  1847.    }
  1848. }
  1849.  
  1850.  
  1851.  
  1852.  
  1853. void gl_GetFloatv( GLcontext *ctx, GLenum pname, GLfloat *params )
  1854. {
  1855.    GLuint i;
  1856.    GLuint texSet = ctx->Texture.CurrentSet;
  1857.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  1858.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  1859.  
  1860.    if (INSIDE_BEGIN_END(ctx)) {
  1861.       gl_error( ctx, GL_INVALID_OPERATION, "glGetFloatv" );
  1862.       return;
  1863.    }
  1864.    switch (pname) {
  1865.       case GL_ACCUM_RED_BITS:
  1866.       case GL_ACCUM_GREEN_BITS:
  1867.       case GL_ACCUM_BLUE_BITS:
  1868.       case GL_ACCUM_ALPHA_BITS:
  1869.          *params = (GLfloat) ctx->Visual->AccumBits;
  1870.          break;
  1871.       case GL_ACCUM_CLEAR_VALUE:
  1872.          params[0] = ctx->Accum.ClearColor[0];
  1873.          params[1] = ctx->Accum.ClearColor[1];
  1874.          params[2] = ctx->Accum.ClearColor[2];
  1875.          params[3] = ctx->Accum.ClearColor[3];
  1876.          break;
  1877.       case GL_ALPHA_BIAS:
  1878.          *params = ctx->Pixel.AlphaBias;
  1879.          break;
  1880.       case GL_ALPHA_BITS:
  1881.          *params = (GLfloat) ctx->Visual->AlphaBits;
  1882.          break;
  1883.       case GL_ALPHA_SCALE:
  1884.          *params = ctx->Pixel.AlphaScale;
  1885.          break;
  1886.       case GL_ALPHA_TEST:
  1887.          *params = (GLfloat) ctx->Color.AlphaEnabled;
  1888.          break;
  1889.       case GL_ALPHA_TEST_FUNC:
  1890.          *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
  1891.          break;
  1892.       case GL_ALPHA_TEST_REF:
  1893.          *params = (GLfloat) ctx->Color.AlphaRef / 255.0;
  1894.          break;
  1895.       case GL_ATTRIB_STACK_DEPTH:
  1896.          *params = (GLfloat) (ctx->AttribStackDepth);
  1897.          break;
  1898.       case GL_AUTO_NORMAL:
  1899.          *params = (GLfloat) ctx->Eval.AutoNormal;
  1900.          break;
  1901.       case GL_AUX_BUFFERS:
  1902.          *params = (GLfloat) NUM_AUX_BUFFERS;
  1903.          break;
  1904.       case GL_BLEND:
  1905.          *params = (GLfloat) ctx->Color.BlendEnabled;
  1906.          break;
  1907.       case GL_BLEND_DST:
  1908.          *params = ENUM_TO_FLOAT(ctx->Color.BlendDst);
  1909.          break;
  1910.       case GL_BLEND_SRC:
  1911.          *params = ENUM_TO_FLOAT(ctx->Color.BlendSrc);
  1912.          break;
  1913.       case GL_BLEND_EQUATION_EXT:
  1914.          *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation);
  1915.          break;
  1916.       case GL_BLEND_COLOR_EXT:
  1917.          params[0] = ctx->Color.BlendColor[0];
  1918.          params[1] = ctx->Color.BlendColor[1];
  1919.          params[2] = ctx->Color.BlendColor[2];
  1920.          params[3] = ctx->Color.BlendColor[3];
  1921.          break;
  1922.       case GL_BLUE_BIAS:
  1923.          *params = ctx->Pixel.BlueBias;
  1924.          break;
  1925.       case GL_BLUE_BITS:
  1926.          *params = (GLfloat) ctx->Visual->BlueBits;
  1927.          break;
  1928.       case GL_BLUE_SCALE:
  1929.          *params = ctx->Pixel.BlueScale;
  1930.          break;
  1931.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  1932.          *params = (GLfloat) (ctx->ClientAttribStackDepth);
  1933.          break;
  1934.       case GL_CLIP_PLANE0:
  1935.       case GL_CLIP_PLANE1:
  1936.       case GL_CLIP_PLANE2:
  1937.       case GL_CLIP_PLANE3:
  1938.       case GL_CLIP_PLANE4:
  1939.       case GL_CLIP_PLANE5:
  1940.          *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1941.          break;
  1942.       case GL_COLOR_CLEAR_VALUE:
  1943.          params[0] = (GLfloat) ctx->Color.ClearColor[0];
  1944.          params[1] = (GLfloat) ctx->Color.ClearColor[1];
  1945.          params[2] = (GLfloat) ctx->Color.ClearColor[2];
  1946.          params[3] = (GLfloat) ctx->Color.ClearColor[3];
  1947.          break;
  1948.       case GL_COLOR_MATERIAL:
  1949.          *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
  1950.          break;
  1951.       case GL_COLOR_MATERIAL_FACE:
  1952.          *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
  1953.          break;
  1954.       case GL_COLOR_MATERIAL_PARAMETER:
  1955.          *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
  1956.          break;
  1957.       case GL_COLOR_WRITEMASK:
  1958.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F;
  1959.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F;
  1960.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F;
  1961.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F;
  1962.          break;
  1963.       case GL_CULL_FACE:
  1964.          *params = (GLfloat) ctx->Polygon.CullFlag;
  1965.          break;
  1966.       case GL_CULL_FACE_MODE:
  1967.          *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
  1968.          break;
  1969.       case GL_CURRENT_COLOR:
  1970.          params[0] = (GLfloat) ctx->Current.ByteColor[0] / 255.0F;
  1971.          params[1] = (GLfloat) ctx->Current.ByteColor[1] / 255.0F;
  1972.          params[2] = (GLfloat) ctx->Current.ByteColor[2] / 255.0F;
  1973.          params[3] = (GLfloat) ctx->Current.ByteColor[3] / 255.0F;
  1974.          break;
  1975.       case GL_CURRENT_INDEX:
  1976.          *params = (GLfloat) ctx->Current.Index;
  1977.          break;
  1978.       case GL_CURRENT_NORMAL:
  1979.          params[0] = ctx->Current.Normal[0];
  1980.          params[1] = ctx->Current.Normal[1];
  1981.          params[2] = ctx->Current.Normal[2];
  1982.          break;
  1983.       case GL_CURRENT_RASTER_COLOR:
  1984.          params[0] = ctx->Current.RasterColor[0];
  1985.          params[1] = ctx->Current.RasterColor[1];
  1986.          params[2] = ctx->Current.RasterColor[2];
  1987.          params[3] = ctx->Current.RasterColor[3];
  1988.          break;
  1989.       case GL_CURRENT_RASTER_DISTANCE:
  1990.          params[0] = ctx->Current.RasterDistance;
  1991.          break;
  1992.       case GL_CURRENT_RASTER_INDEX:
  1993.          *params = (GLfloat) ctx->Current.RasterIndex;
  1994.          break;
  1995.       case GL_CURRENT_RASTER_POSITION:
  1996.          params[0] = ctx->Current.RasterPos[0];
  1997.          params[1] = ctx->Current.RasterPos[1];
  1998.          params[2] = ctx->Current.RasterPos[2];
  1999.          params[3] = ctx->Current.RasterPos[3];
  2000.          break;
  2001.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2002.          params[0] = ctx->Current.RasterMultiTexCoord[texTransformSet][0];
  2003.          params[1] = ctx->Current.RasterMultiTexCoord[texTransformSet][1];
  2004.          params[2] = ctx->Current.RasterMultiTexCoord[texTransformSet][2];
  2005.          params[3] = ctx->Current.RasterMultiTexCoord[texTransformSet][3];
  2006.          break;
  2007.       case GL_CURRENT_RASTER_POSITION_VALID:
  2008.          *params = (GLfloat) ctx->Current.RasterPosValid;
  2009.          break;
  2010.       case GL_CURRENT_TEXTURE_COORDS:
  2011.          params[0] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][0];
  2012.          params[1] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][1];
  2013.          params[2] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][2];
  2014.          params[3] = (GLfloat) ctx->Current.MultiTexCoord[texTransformSet][3];
  2015.          break;
  2016.       case GL_DEPTH_BIAS:
  2017.          *params = (GLfloat) ctx->Pixel.DepthBias;
  2018.          break;
  2019.       case GL_DEPTH_BITS:
  2020.          *params = (GLfloat) ctx->Visual->DepthBits;
  2021.          break;
  2022.       case GL_DEPTH_CLEAR_VALUE:
  2023.          *params = (GLfloat) ctx->Depth.Clear;
  2024.          break;
  2025.       case GL_DEPTH_FUNC:
  2026.          *params = ENUM_TO_FLOAT(ctx->Depth.Func);
  2027.          break;
  2028.       case GL_DEPTH_RANGE:
  2029.          params[0] = (GLfloat) ctx->Viewport.Near;
  2030.          params[1] = (GLfloat) ctx->Viewport.Far;
  2031.          break;
  2032.       case GL_DEPTH_SCALE:
  2033.          *params = (GLfloat) ctx->Pixel.DepthScale;
  2034.          break;
  2035.       case GL_DEPTH_TEST:
  2036.          *params = (GLfloat) ctx->Depth.Test;
  2037.          break;
  2038.       case GL_DEPTH_WRITEMASK:
  2039.          *params = (GLfloat) ctx->Depth.Mask;
  2040.          break;
  2041.       case GL_DITHER:
  2042.          *params = (GLfloat) ctx->Color.DitherFlag;
  2043.          break;
  2044.       case GL_DOUBLEBUFFER:
  2045.          *params = (GLfloat) ctx->Visual->DBflag;
  2046.          break;
  2047.       case GL_DRAW_BUFFER:
  2048.          *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
  2049.          break;
  2050.       case GL_EDGE_FLAG:
  2051.          *params = (GLfloat) ctx->Current.EdgeFlag;
  2052.          break;
  2053.       case GL_FEEDBACK_BUFFER_SIZE:
  2054.          /* TODO: is this right?  Or, return number of entries in buffer? */
  2055.          *params = (GLfloat) ctx->Feedback.BufferSize;
  2056.          break;
  2057.       case GL_FEEDBACK_BUFFER_TYPE:
  2058.          *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
  2059.          break;
  2060.       case GL_FOG:
  2061.          *params = (GLfloat) ctx->Fog.Enabled;
  2062.          break;
  2063.       case GL_FOG_COLOR:
  2064.          params[0] = ctx->Fog.Color[0];
  2065.          params[1] = ctx->Fog.Color[1];
  2066.          params[2] = ctx->Fog.Color[2];
  2067.          params[3] = ctx->Fog.Color[3];
  2068.          break;
  2069.       case GL_FOG_DENSITY:
  2070.          *params = ctx->Fog.Density;
  2071.          break;
  2072.       case GL_FOG_END:
  2073.          *params = ctx->Fog.End;
  2074.          break;
  2075.       case GL_FOG_HINT:
  2076.          *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
  2077.          break;
  2078.       case GL_FOG_INDEX:
  2079.          *params = ctx->Fog.Index;
  2080.          break;
  2081.       case GL_FOG_MODE:
  2082.          *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
  2083.          break;
  2084.       case GL_FOG_START:
  2085.          *params = ctx->Fog.Start;
  2086.          break;
  2087.       case GL_FRONT_FACE:
  2088.          *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
  2089.          break;
  2090.       case GL_GREEN_BIAS:
  2091.          *params = (GLfloat) ctx->Pixel.GreenBias;
  2092.          break;
  2093.       case GL_GREEN_BITS:
  2094.          *params = (GLfloat) ctx->Visual->GreenBits;
  2095.          break;
  2096.       case GL_GREEN_SCALE:
  2097.          *params = (GLfloat) ctx->Pixel.GreenScale;
  2098.          break;
  2099.       case GL_INDEX_BITS:
  2100.          *params = (GLfloat) ctx->Visual->IndexBits;
  2101.          break;
  2102.       case GL_INDEX_CLEAR_VALUE:
  2103.          *params = (GLfloat) ctx->Color.ClearIndex;
  2104.          break;
  2105.       case GL_INDEX_MODE:
  2106.          *params = ctx->Visual->RGBAflag ? 0.0F : 1.0F;
  2107.          break;
  2108.       case GL_INDEX_OFFSET:
  2109.          *params = (GLfloat) ctx->Pixel.IndexOffset;
  2110.          break;
  2111.       case GL_INDEX_SHIFT:
  2112.          *params = (GLfloat) ctx->Pixel.IndexShift;
  2113.          break;
  2114.       case GL_INDEX_WRITEMASK:
  2115.          *params = (GLfloat) ctx->Color.IndexMask;
  2116.          break;
  2117.       case GL_LIGHT0:
  2118.       case GL_LIGHT1:
  2119.       case GL_LIGHT2:
  2120.       case GL_LIGHT3:
  2121.       case GL_LIGHT4:
  2122.       case GL_LIGHT5:
  2123.       case GL_LIGHT6:
  2124.       case GL_LIGHT7:
  2125.          *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  2126.          break;
  2127.       case GL_LIGHTING:
  2128.          *params = (GLfloat) ctx->Light.Enabled;
  2129.          break;
  2130.       case GL_LIGHT_MODEL_AMBIENT:
  2131.          params[0] = ctx->Light.Model.Ambient[0];
  2132.          params[1] = ctx->Light.Model.Ambient[1];
  2133.          params[2] = ctx->Light.Model.Ambient[2];
  2134.          params[3] = ctx->Light.Model.Ambient[3];
  2135.          break;
  2136.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  2137.          params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
  2138.          break;
  2139.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  2140.          *params = (GLfloat) ctx->Light.Model.LocalViewer;
  2141.          break;
  2142.       case GL_LIGHT_MODEL_TWO_SIDE:
  2143.          *params = (GLfloat) ctx->Light.Model.TwoSide;
  2144.          break;
  2145.       case GL_LINE_SMOOTH:
  2146.          *params = (GLfloat) ctx->Line.SmoothFlag;
  2147.          break;
  2148.       case GL_LINE_SMOOTH_HINT:
  2149.          *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
  2150.          break;
  2151.       case GL_LINE_STIPPLE:
  2152.          *params = (GLfloat) ctx->Line.StippleFlag;
  2153.          break;
  2154.       case GL_LINE_STIPPLE_PATTERN:
  2155.          *params = (GLfloat) ctx->Line.StipplePattern;
  2156.          break;
  2157.       case GL_LINE_STIPPLE_REPEAT:
  2158.          *params = (GLfloat) ctx->Line.StippleFactor;
  2159.          break;
  2160.       case GL_LINE_WIDTH:
  2161.          *params = (GLfloat) ctx->Line.Width;
  2162.          break;
  2163.       case GL_LINE_WIDTH_GRANULARITY:
  2164.          *params = (GLfloat) LINE_WIDTH_GRANULARITY;
  2165.          break;
  2166.       case GL_LINE_WIDTH_RANGE:
  2167.          params[0] = (GLfloat) MIN_LINE_WIDTH;
  2168.          params[1] = (GLfloat) MAX_LINE_WIDTH;
  2169.          break;
  2170.       case GL_LIST_BASE:
  2171.          *params = (GLfloat) ctx->List.ListBase;
  2172.          break;
  2173.       case GL_LIST_INDEX:
  2174.          *params = (GLfloat) ctx->CurrentListNum;
  2175.          break;
  2176.       case GL_LIST_MODE:
  2177.          *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
  2178.                                   : ENUM_TO_FLOAT(GL_COMPILE);
  2179.          break;
  2180.       case GL_INDEX_LOGIC_OP:
  2181.          *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
  2182.          break;
  2183.       case GL_COLOR_LOGIC_OP:
  2184.          *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
  2185.          break;
  2186.       case GL_LOGIC_OP_MODE:
  2187.          *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
  2188.          break;
  2189.       case GL_MAP1_COLOR_4:
  2190.          *params = (GLfloat) ctx->Eval.Map1Color4;
  2191.          break;
  2192.       case GL_MAP1_GRID_DOMAIN:
  2193.          params[0] = ctx->Eval.MapGrid1u1;
  2194.          params[1] = ctx->Eval.MapGrid1u2;
  2195.          break;
  2196.       case GL_MAP1_GRID_SEGMENTS:
  2197.          *params = (GLfloat) ctx->Eval.MapGrid1un;
  2198.          break;
  2199.       case GL_MAP1_INDEX:
  2200.          *params = (GLfloat) ctx->Eval.Map1Index;
  2201.          break;
  2202.       case GL_MAP1_NORMAL:
  2203.          *params = (GLfloat) ctx->Eval.Map1Normal;
  2204.          break;
  2205.       case GL_MAP1_TEXTURE_COORD_1:
  2206.          *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
  2207.          break;
  2208.       case GL_MAP1_TEXTURE_COORD_2:
  2209.          *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
  2210.          break;
  2211.       case GL_MAP1_TEXTURE_COORD_3:
  2212.          *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
  2213.          break;
  2214.       case GL_MAP1_TEXTURE_COORD_4:
  2215.          *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
  2216.          break;
  2217.       case GL_MAP1_VERTEX_3:
  2218.          *params = (GLfloat) ctx->Eval.Map1Vertex3;
  2219.          break;
  2220.       case GL_MAP1_VERTEX_4:
  2221.          *params = (GLfloat) ctx->Eval.Map1Vertex4;
  2222.          break;
  2223.       case GL_MAP2_COLOR_4:
  2224.          *params = (GLfloat) ctx->Eval.Map2Color4;
  2225.          break;
  2226.       case GL_MAP2_GRID_DOMAIN:
  2227.          params[0] = ctx->Eval.MapGrid2u1;
  2228.          params[1] = ctx->Eval.MapGrid2u2;
  2229.          params[2] = ctx->Eval.MapGrid2v1;
  2230.          params[3] = ctx->Eval.MapGrid2v2;
  2231.          break;
  2232.       case GL_MAP2_GRID_SEGMENTS:
  2233.          params[0] = (GLfloat) ctx->Eval.MapGrid2un;
  2234.          params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
  2235.          break;
  2236.       case GL_MAP2_INDEX:
  2237.          *params = (GLfloat) ctx->Eval.Map2Index;
  2238.          break;
  2239.       case GL_MAP2_NORMAL:
  2240.          *params = (GLfloat) ctx->Eval.Map2Normal;
  2241.          break;
  2242.       case GL_MAP2_TEXTURE_COORD_1:
  2243.          *params = ctx->Eval.Map2TextureCoord1;
  2244.          break;
  2245.       case GL_MAP2_TEXTURE_COORD_2:
  2246.          *params = ctx->Eval.Map2TextureCoord2;
  2247.          break;
  2248.       case GL_MAP2_TEXTURE_COORD_3:
  2249.          *params = ctx->Eval.Map2TextureCoord3;
  2250.          break;
  2251.       case GL_MAP2_TEXTURE_COORD_4:
  2252.          *params = ctx->Eval.Map2TextureCoord4;
  2253.          break;
  2254.       case GL_MAP2_VERTEX_3:
  2255.          *params = (GLfloat) ctx->Eval.Map2Vertex3;
  2256.          break;
  2257.       case GL_MAP2_VERTEX_4:
  2258.          *params = (GLfloat) ctx->Eval.Map2Vertex4;
  2259.          break;
  2260.       case GL_MAP_COLOR:
  2261.          *params = (GLfloat) ctx->Pixel.MapColorFlag;
  2262.          break;
  2263.       case GL_MAP_STENCIL:
  2264.          *params = (GLfloat) ctx->Pixel.MapStencilFlag;
  2265.          break;
  2266.       case GL_MATRIX_MODE:
  2267.          *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
  2268.          break;
  2269.       case GL_MAX_ATTRIB_STACK_DEPTH:
  2270.          *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
  2271.          break;
  2272.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  2273.          *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  2274.          break;
  2275.       case GL_MAX_CLIP_PLANES:
  2276.          *params = (GLfloat) MAX_CLIP_PLANES;
  2277.          break;
  2278.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  2279.          *params = (GLfloat) VB_MAX;
  2280.          break;
  2281.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  2282.          *params = (GLfloat) VB_MAX;
  2283.          break;
  2284.       case GL_MAX_EVAL_ORDER:
  2285.          *params = (GLfloat) MAX_EVAL_ORDER;
  2286.          break;
  2287.       case GL_MAX_LIGHTS:
  2288.          *params = (GLfloat) MAX_LIGHTS;
  2289.          break;
  2290.       case GL_MAX_LIST_NESTING:
  2291.          *params = (GLfloat) MAX_LIST_NESTING;
  2292.          break;
  2293.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  2294.          *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
  2295.          break;
  2296.       case GL_MAX_NAME_STACK_DEPTH:
  2297.          *params = (GLfloat) MAX_NAME_STACK_DEPTH;
  2298.          break;
  2299.       case GL_MAX_PIXEL_MAP_TABLE:
  2300.          *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
  2301.          break;
  2302.       case GL_MAX_PROJECTION_STACK_DEPTH:
  2303.          *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
  2304.          break;
  2305.       case GL_MAX_TEXTURE_SIZE:
  2306.          *params = (GLfloat) max_texture_size(ctx);
  2307.          break;
  2308.       case GL_MAX_TEXTURE_STACK_DEPTH:
  2309.          *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
  2310.          break;
  2311.       case GL_MAX_VIEWPORT_DIMS:
  2312.          params[0] = (GLfloat) MAX_WIDTH;
  2313.          params[1] = (GLfloat) MAX_HEIGHT;
  2314.          break;
  2315.       case GL_MODELVIEW_MATRIX:
  2316.          for (i=0;i<16;i++) {
  2317.             params[i] = ctx->ModelViewMatrix[i];
  2318.          }
  2319.          break;
  2320.       case GL_MODELVIEW_STACK_DEPTH:
  2321.          *params = (GLfloat) (ctx->ModelViewStackDepth + 1);
  2322.          break;
  2323.       case GL_NAME_STACK_DEPTH:
  2324.          *params = (GLfloat) ctx->Select.NameStackDepth;
  2325.          break;
  2326.       case GL_NORMALIZE:
  2327.          *params = (GLfloat) ctx->Transform.Normalize;
  2328.          break;
  2329.       case GL_PACK_ALIGNMENT:
  2330.          *params = (GLfloat) ctx->Pack.Alignment;
  2331.          break;
  2332.       case GL_PACK_LSB_FIRST:
  2333.          *params = (GLfloat) ctx->Pack.LsbFirst;
  2334.          break;
  2335.       case GL_PACK_ROW_LENGTH:
  2336.          *params = (GLfloat) ctx->Pack.RowLength;
  2337.          break;
  2338.       case GL_PACK_SKIP_PIXELS:
  2339.          *params = (GLfloat) ctx->Pack.SkipPixels;
  2340.          break;
  2341.       case GL_PACK_SKIP_ROWS:
  2342.          *params = (GLfloat) ctx->Pack.SkipRows;
  2343.          break;
  2344.       case GL_PACK_SWAP_BYTES:
  2345.          *params = (GLfloat) ctx->Pack.SwapBytes;
  2346.          break;
  2347.       case GL_PACK_SKIP_IMAGES_EXT:
  2348.          *params = (GLfloat) ctx->Pack.SkipImages;
  2349.          break;
  2350.       case GL_PACK_IMAGE_HEIGHT_EXT:
  2351.          *params = (GLfloat) ctx->Pack.ImageHeight;
  2352.          break;
  2353.       case GL_PERSPECTIVE_CORRECTION_HINT:
  2354.          *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
  2355.          break;
  2356.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  2357.          *params = (GLfloat) ctx->Pixel.MapAtoAsize;
  2358.          break;
  2359.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  2360.          *params = (GLfloat) ctx->Pixel.MapBtoBsize;
  2361.          break;
  2362.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  2363.          *params = (GLfloat) ctx->Pixel.MapGtoGsize;
  2364.          break;
  2365.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  2366.          *params = (GLfloat) ctx->Pixel.MapItoAsize;
  2367.          break;
  2368.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  2369.          *params = (GLfloat) ctx->Pixel.MapItoBsize;
  2370.          break;
  2371.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  2372.          *params = (GLfloat) ctx->Pixel.MapItoGsize;
  2373.          break;
  2374.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  2375.          *params = (GLfloat) ctx->Pixel.MapItoIsize;
  2376.          break;
  2377.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  2378.          *params = (GLfloat) ctx->Pixel.MapItoRsize;
  2379.          break;
  2380.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  2381.          *params = (GLfloat) ctx->Pixel.MapRtoRsize;
  2382.          break;
  2383.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  2384.          *params = (GLfloat) ctx->Pixel.MapStoSsize;
  2385.          break;
  2386.       case GL_POINT_SIZE:
  2387.          *params = (GLfloat) ctx->Point.Size;
  2388.          break;
  2389.       case GL_POINT_SIZE_GRANULARITY:
  2390.          *params = (GLfloat) POINT_SIZE_GRANULARITY;
  2391.          break;
  2392.       case GL_POINT_SIZE_RANGE:
  2393.          params[0] = (GLfloat) MIN_POINT_SIZE;
  2394.          params[1] = (GLfloat) MAX_POINT_SIZE;
  2395.          break;
  2396.       case GL_POINT_SMOOTH:
  2397.          *params = (GLfloat) ctx->Point.SmoothFlag;
  2398.          break;
  2399.       case GL_POINT_SMOOTH_HINT:
  2400.          *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
  2401.          break;
  2402.       case GL_POINT_SIZE_MIN_EXT:
  2403.          *params = (GLfloat) (ctx->Point.MinSize);
  2404.          break;
  2405.       case GL_POINT_SIZE_MAX_EXT:
  2406.          *params = (GLfloat) (ctx->Point.MaxSize);
  2407.          break;
  2408.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  2409.          *params = (GLfloat) (ctx->Point.Threshold);
  2410.          break;
  2411.       case GL_DISTANCE_ATTENUATION_EXT:
  2412.          params[0] = (GLfloat) (ctx->Point.Params[0]);
  2413.          params[1] = (GLfloat) (ctx->Point.Params[1]);
  2414.          params[2] = (GLfloat) (ctx->Point.Params[2]);
  2415.          break;
  2416.       case GL_POLYGON_MODE:
  2417.          params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
  2418.          params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
  2419.          break;
  2420. #ifdef GL_EXT_polygon_offset
  2421.       case GL_POLYGON_OFFSET_BIAS_EXT:
  2422.          *params = ctx->Polygon.OffsetUnits;
  2423.          break;
  2424. #endif
  2425.       case GL_POLYGON_OFFSET_FACTOR:
  2426.          *params = ctx->Polygon.OffsetFactor;
  2427.          break;
  2428.       case GL_POLYGON_OFFSET_UNITS:
  2429.          *params = ctx->Polygon.OffsetUnits;
  2430.          break;
  2431.       case GL_POLYGON_SMOOTH:
  2432.          *params = (GLfloat) ctx->Polygon.SmoothFlag;
  2433.          break;
  2434.       case GL_POLYGON_SMOOTH_HINT:
  2435.          *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
  2436.          break;
  2437.       case GL_POLYGON_STIPPLE:
  2438.          *params = (GLfloat) ctx->Polygon.StippleFlag;
  2439.          break;
  2440.       case GL_PROJECTION_MATRIX:
  2441.          for (i=0;i<16;i++) {
  2442.             params[i] = ctx->ProjectionMatrix[i];
  2443.          }
  2444.          break;
  2445.       case GL_PROJECTION_STACK_DEPTH:
  2446.          *params = (GLfloat) (ctx->ProjectionStackDepth + 1);
  2447.          break;
  2448.       case GL_READ_BUFFER:
  2449.          *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
  2450.          break;
  2451.       case GL_RED_BIAS:
  2452.          *params = ctx->Pixel.RedBias;
  2453.          break;
  2454.       case GL_RED_BITS:
  2455.          *params = (GLfloat) ctx->Visual->RedBits;
  2456.          break;
  2457.       case GL_RED_SCALE:
  2458.          *params = ctx->Pixel.RedScale;
  2459.          break;
  2460.       case GL_RENDER_MODE:
  2461.          *params = ENUM_TO_FLOAT(ctx->RenderMode);
  2462.          break;
  2463.       case GL_RGBA_MODE:
  2464.          *params = (GLfloat) ctx->Visual->RGBAflag;
  2465.          break;
  2466.       case GL_SCISSOR_BOX:
  2467.          params[0] = (GLfloat) ctx->Scissor.X;
  2468.          params[1] = (GLfloat) ctx->Scissor.Y;
  2469.          params[2] = (GLfloat) ctx->Scissor.Width;
  2470.          params[3] = (GLfloat) ctx->Scissor.Height;
  2471.          break;
  2472.       case GL_SCISSOR_TEST:
  2473.          *params = (GLfloat) ctx->Scissor.Enabled;
  2474.          break;
  2475.       case GL_SELECTION_BUFFER_SIZE:
  2476.          *params = (GLfloat) ctx->Select.BufferSize;
  2477.          break;
  2478.       case GL_SHADE_MODEL:
  2479.          *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
  2480.          break;
  2481.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  2482.          *params = (GLfloat) ctx->Texture.SharedPalette;
  2483.          break;
  2484.       case GL_STENCIL_BITS:
  2485.          *params = (GLfloat) ctx->Visual->StencilBits;
  2486.          break;
  2487.       case GL_STENCIL_CLEAR_VALUE:
  2488.          *params = (GLfloat) ctx->Stencil.Clear;
  2489.          break;
  2490.       case GL_STENCIL_FAIL:
  2491.          *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
  2492.          break;
  2493.       case GL_STENCIL_FUNC:
  2494.          *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
  2495.          break;
  2496.       case GL_STENCIL_PASS_DEPTH_FAIL:
  2497.          *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
  2498.          break;
  2499.       case GL_STENCIL_PASS_DEPTH_PASS:
  2500.          *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
  2501.          break;
  2502.       case GL_STENCIL_REF:
  2503.          *params = (GLfloat) ctx->Stencil.Ref;
  2504.          break;
  2505.       case GL_STENCIL_TEST:
  2506.          *params = (GLfloat) ctx->Stencil.Enabled;
  2507.          break;
  2508.       case GL_STENCIL_VALUE_MASK:
  2509.          *params = (GLfloat) ctx->Stencil.ValueMask;
  2510.          break;
  2511.       case GL_STENCIL_WRITEMASK:
  2512.          *params = (GLfloat) ctx->Stencil.WriteMask;
  2513.          break;
  2514.       case GL_STEREO:
  2515.          *params = 0.0F;  /* TODO */
  2516.          break;
  2517.       case GL_SUBPIXEL_BITS:
  2518.          *params = 0.0F;  /* TODO */
  2519.          break;
  2520.       case GL_TEXTURE_1D:
  2521.          {
  2522.             GLuint bit = TEXTURE0_1D << (texSet * 4);
  2523.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  2524.          }
  2525.          break;
  2526.       case GL_TEXTURE_2D:
  2527.          {
  2528.             GLuint bit = TEXTURE0_2D << (texSet * 4);
  2529.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  2530.          }
  2531.          break;
  2532.       case GL_TEXTURE_3D:
  2533.          {
  2534.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  2535.             *params = (ctx->Texture.Enabled & bit) ? 1.0 : 0.0;
  2536.          }
  2537.          break;
  2538.       case GL_TEXTURE_BINDING_1D:
  2539.          *params = (GLfloat) textureSet->Current1D->Name;
  2540.           break;
  2541.       case GL_TEXTURE_BINDING_2D:
  2542.          *params = (GLfloat) textureSet->Current2D->Name;
  2543.           break;
  2544.       case GL_TEXTURE_BINDING_3D:
  2545.          *params = (GLfloat) textureSet->Current2D->Name;
  2546.           break;
  2547.       case GL_TEXTURE_ENV_COLOR:
  2548.          params[0] = textureSet->EnvColor[0];
  2549.          params[1] = textureSet->EnvColor[1];
  2550.          params[2] = textureSet->EnvColor[2];
  2551.          params[3] = textureSet->EnvColor[3];
  2552.          break;
  2553.       case GL_TEXTURE_ENV_MODE:
  2554.          *params = ENUM_TO_FLOAT(textureSet->EnvMode);
  2555.          break;
  2556.       case GL_TEXTURE_GEN_S:
  2557.          *params = (textureSet->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  2558.          break;
  2559.       case GL_TEXTURE_GEN_T:
  2560.          *params = (textureSet->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  2561.          break;
  2562.       case GL_TEXTURE_GEN_R:
  2563.          *params = (textureSet->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  2564.          break;
  2565.       case GL_TEXTURE_GEN_Q:
  2566.          *params = (textureSet->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  2567.          break;
  2568.       case GL_TEXTURE_MATRIX:
  2569.          for (i=0;i<16;i++) {
  2570.             params[i] = ctx->TextureMatrix[texTransformSet][i];
  2571.          }
  2572.          break;
  2573.       case GL_TEXTURE_STACK_DEPTH:
  2574.          *params = (GLfloat) (ctx->TextureStackDepth[texTransformSet] + 1);
  2575.          break;
  2576.       case GL_UNPACK_ALIGNMENT:
  2577.          *params = (GLfloat) ctx->Unpack.Alignment;
  2578.          break;
  2579.       case GL_UNPACK_LSB_FIRST:
  2580.          *params = (GLfloat) ctx->Unpack.LsbFirst;
  2581.          break;
  2582.       case GL_UNPACK_ROW_LENGTH:
  2583.          *params = (GLfloat) ctx->Unpack.RowLength;
  2584.          break;
  2585.       case GL_UNPACK_SKIP_PIXELS:
  2586.          *params = (GLfloat) ctx->Unpack.SkipPixels;
  2587.          break;
  2588.       case GL_UNPACK_SKIP_ROWS:
  2589.          *params = (GLfloat) ctx->Unpack.SkipRows;
  2590.          break;
  2591.       case GL_UNPACK_SWAP_BYTES:
  2592.          *params = (GLfloat) ctx->Unpack.SwapBytes;
  2593.          break;
  2594.       case GL_UNPACK_SKIP_IMAGES_EXT:
  2595.          *params = (GLfloat) ctx->Unpack.SkipImages;
  2596.          break;
  2597.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  2598.          *params = (GLfloat) ctx->Unpack.ImageHeight;
  2599.          break;
  2600.       case GL_VIEWPORT:
  2601.          params[0] = (GLfloat) ctx->Viewport.X;
  2602.          params[1] = (GLfloat) ctx->Viewport.Y;
  2603.          params[2] = (GLfloat) ctx->Viewport.Width;
  2604.          params[3] = (GLfloat) ctx->Viewport.Height;
  2605.          break;
  2606.       case GL_ZOOM_X:
  2607.          *params = (GLfloat) ctx->Pixel.ZoomX;
  2608.          break;
  2609.       case GL_ZOOM_Y:
  2610.          *params = (GLfloat) ctx->Pixel.ZoomY;
  2611.          break;
  2612.       case GL_VERTEX_ARRAY_SIZE:
  2613.          *params = (GLfloat) ctx->Array.VertexSize;
  2614.          break;
  2615.       case GL_VERTEX_ARRAY_TYPE:
  2616.          *params = ENUM_TO_FLOAT(ctx->Array.VertexType);
  2617.          break;
  2618.       case GL_VERTEX_ARRAY_STRIDE:
  2619.          *params = (GLfloat) ctx->Array.VertexStride;
  2620.          break;
  2621.       case GL_VERTEX_ARRAY_COUNT_EXT:
  2622.          *params = 0.0;
  2623.          break;
  2624.       case GL_NORMAL_ARRAY_TYPE:
  2625.          *params = ENUM_TO_FLOAT(ctx->Array.NormalType);
  2626.          break;
  2627.       case GL_NORMAL_ARRAY_STRIDE:
  2628.          *params = (GLfloat) ctx->Array.NormalStride;
  2629.          break;
  2630.       case GL_NORMAL_ARRAY_COUNT_EXT:
  2631.          *params = 0.0;
  2632.          break;
  2633.       case GL_COLOR_ARRAY_SIZE:
  2634.          *params = (GLfloat) ctx->Array.ColorSize;
  2635.          break;
  2636.       case GL_COLOR_ARRAY_TYPE:
  2637.          *params = ENUM_TO_FLOAT(ctx->Array.ColorType);
  2638.          break;
  2639.       case GL_COLOR_ARRAY_STRIDE:
  2640.          *params = (GLfloat) ctx->Array.ColorStride;
  2641.          break;
  2642.       case GL_COLOR_ARRAY_COUNT_EXT:
  2643.          *params = 0.0;
  2644.          break;
  2645.       case GL_INDEX_ARRAY_TYPE:
  2646.          *params = ENUM_TO_FLOAT(ctx->Array.IndexType);
  2647.          break;
  2648.       case GL_INDEX_ARRAY_STRIDE:
  2649.          *params = (GLfloat) ctx->Array.IndexStride;
  2650.          break;
  2651.       case GL_INDEX_ARRAY_COUNT_EXT:
  2652.          *params = 0.0;
  2653.          break;
  2654.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  2655.          *params = (GLfloat) ctx->Array.TexCoordSize[texSet];
  2656.          break;
  2657.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  2658.          *params = ENUM_TO_FLOAT(ctx->Array.TexCoordType[texSet]);
  2659.          break;
  2660.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  2661.          *params = (GLfloat) ctx->Array.TexCoordStride[texSet];
  2662.          break;
  2663.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  2664.          *params = 0.0;
  2665.          break;
  2666.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  2667.          *params = (GLfloat) ctx->Array.EdgeFlagStride;
  2668.          break;
  2669.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  2670.          *params = 0.0;
  2671.          break;
  2672.  
  2673.       /* GL_SGIS_multitexture */
  2674.       case GL_SELECTED_TEXTURE_SGIS:
  2675.          *params = (GLfloat) ctx->Texture.CurrentSet;
  2676.          break;
  2677.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  2678.          *params = (GLfloat) ctx->TexCoordSet;
  2679.          break;
  2680.       case GL_MAX_TEXTURES_SGIS:
  2681.          *params = (GLfloat) max_textures(ctx);
  2682.          break;
  2683.  
  2684.       /* GL_EXT_multitexture */
  2685.       case GL_SELECTED_TEXTURE_EXT:
  2686.          *params = (GLfloat) ctx->Texture.CurrentSet;
  2687.          break;
  2688.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  2689.          *params = (GLfloat) ctx->TexCoordSet;
  2690.          break;
  2691.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  2692.          *params = (GLfloat) ctx->Texture.CurrentTransformSet;
  2693.          break;
  2694.       case GL_MAX_TEXTURES_EXT:
  2695.          *params = (GLfloat) max_textures(ctx);
  2696.          break;
  2697.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  2698.          *params = (GLfloat) MAX_TEX_COORD_SETS;
  2699.          break;
  2700.  
  2701.       default:
  2702.          gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
  2703.    }
  2704. }
  2705.  
  2706.  
  2707.  
  2708.  
  2709. void gl_GetIntegerv( GLcontext *ctx, GLenum pname, GLint *params )
  2710. {
  2711.    GLuint i;
  2712.    GLuint texSet = ctx->Texture.CurrentSet;
  2713.    GLuint texTransformSet = ctx->Texture.CurrentTransformSet;
  2714.    const struct gl_texture_set *textureSet = &ctx->Texture.Set[texSet];
  2715.  
  2716.    if (INSIDE_BEGIN_END(ctx)) {
  2717.       gl_error( ctx, GL_INVALID_OPERATION, "glGetIntegerv" );
  2718.       return;
  2719.    }
  2720.    switch (pname) {
  2721.       case GL_ACCUM_RED_BITS:
  2722.       case GL_ACCUM_GREEN_BITS:
  2723.       case GL_ACCUM_BLUE_BITS:
  2724.       case GL_ACCUM_ALPHA_BITS:
  2725.          *params = (GLint) ctx->Visual->AccumBits;
  2726.          break;
  2727.       case GL_ACCUM_CLEAR_VALUE:
  2728.          params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
  2729.          params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
  2730.          params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
  2731.          params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
  2732.          break;
  2733.       case GL_ALPHA_BIAS:
  2734.          *params = (GLint) ctx->Pixel.AlphaBias;
  2735.          break;
  2736.       case GL_ALPHA_BITS:
  2737.          *params = ctx->Visual->AlphaBits;
  2738.          break;
  2739.       case GL_ALPHA_SCALE:
  2740.          *params = (GLint) ctx->Pixel.AlphaScale;
  2741.          break;
  2742.       case GL_ALPHA_TEST:
  2743.          *params = (GLint) ctx->Color.AlphaEnabled;
  2744.          break;
  2745.       case GL_ALPHA_TEST_REF:
  2746.          *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / 255.0 );
  2747.          break;
  2748.       case GL_ALPHA_TEST_FUNC:
  2749.          *params = (GLint) ctx->Color.AlphaFunc;
  2750.          break;
  2751.       case GL_ATTRIB_STACK_DEPTH:
  2752.          *params = (GLint) (ctx->AttribStackDepth);
  2753.          break;
  2754.       case GL_AUTO_NORMAL:
  2755.          *params = (GLint) ctx->Eval.AutoNormal;
  2756.          break;
  2757.       case GL_AUX_BUFFERS:
  2758.          *params = (GLint) NUM_AUX_BUFFERS;
  2759.          break;
  2760.       case GL_BLEND:
  2761.          *params = (GLint) ctx->Color.BlendEnabled;
  2762.          break;
  2763.       case GL_BLEND_DST:
  2764.          *params = (GLint) ctx->Color.BlendDst;
  2765.          break;
  2766.       case GL_BLEND_SRC:
  2767.          *params = (GLint) ctx->Color.BlendSrc;
  2768.          break;
  2769.       case GL_BLEND_EQUATION_EXT:
  2770.          *params = (GLint) ctx->Color.BlendEquation;
  2771.          break;
  2772.       case GL_BLEND_COLOR_EXT:
  2773.          params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] );
  2774.          params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] );
  2775.          params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] );
  2776.          params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] );
  2777.          break;
  2778.       case GL_BLUE_BIAS:
  2779.          *params = (GLint) ctx->Pixel.BlueBias;
  2780.          break;
  2781.       case GL_BLUE_BITS:
  2782.          *params = (GLint) ctx->Visual->BlueBits;
  2783.          break;
  2784.       case GL_BLUE_SCALE:
  2785.          *params = (GLint) ctx->Pixel.BlueScale;
  2786.          break;
  2787.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  2788.          *params = (GLint) (ctx->ClientAttribStackDepth);
  2789.          break;
  2790.       case GL_CLIP_PLANE0:
  2791.       case GL_CLIP_PLANE1:
  2792.       case GL_CLIP_PLANE2:
  2793.       case GL_CLIP_PLANE3:
  2794.       case GL_CLIP_PLANE4:
  2795.       case GL_CLIP_PLANE5:
  2796.          i = (GLint) (pname - GL_CLIP_PLANE0);
  2797.          *params = (GLint) ctx->Transform.ClipEnabled[i];
  2798.          break;
  2799.       case GL_COLOR_CLEAR_VALUE:
  2800.          params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
  2801.          params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
  2802.          params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
  2803.          params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
  2804.          break;
  2805.       case GL_COLOR_MATERIAL:
  2806.          *params = (GLint) ctx->Light.ColorMaterialEnabled;
  2807.          break;
  2808.       case GL_COLOR_MATERIAL_FACE:
  2809.          *params = (GLint) ctx->Light.ColorMaterialFace;
  2810.          break;
  2811.       case GL_COLOR_MATERIAL_PARAMETER:
  2812.          *params = (GLint) ctx->Light.ColorMaterialMode;
  2813.          break;
  2814.       case GL_COLOR_WRITEMASK:
  2815.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
  2816.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
  2817.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
  2818.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
  2819.          break;
  2820.       case GL_CULL_FACE:
  2821.          *params = (GLint) ctx->Polygon.CullFlag;
  2822.          break;
  2823.       case GL_CULL_FACE_MODE:
  2824.          *params = (GLint) ctx->Polygon.CullFaceMode;
  2825.          break;
  2826.       case GL_CURRENT_COLOR:
  2827.          params[0] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[0] / 255.0F );
  2828.          params[1] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[1] / 255.0F );
  2829.          params[2] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[2] / 255.0F );
  2830.          params[3] = FLOAT_TO_INT( (GLfloat) ctx->Current.ByteColor[3] / 255.0F );
  2831.          break;
  2832.       case GL_CURRENT_INDEX:
  2833.          *params = (GLint) ctx->Current.Index;
  2834.          break;
  2835.       case GL_CURRENT_NORMAL:
  2836.          params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
  2837.          params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
  2838.          params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
  2839.          break;
  2840.       case GL_CURRENT_RASTER_COLOR:
  2841.          params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
  2842.          params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
  2843.          params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
  2844.          params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
  2845.          break;
  2846.       case GL_CURRENT_RASTER_DISTANCE:
  2847.          params[0] = (GLint) ctx->Current.RasterDistance;
  2848.          break;
  2849.       case GL_CURRENT_RASTER_INDEX:
  2850.          *params = (GLint) ctx->Current.RasterIndex;
  2851.          break;
  2852.       case GL_CURRENT_RASTER_POSITION:
  2853.          params[0] = (GLint) ctx->Current.RasterPos[0];
  2854.          params[1] = (GLint) ctx->Current.RasterPos[1];
  2855.          params[2] = (GLint) ctx->Current.RasterPos[2];
  2856.          params[3] = (GLint) ctx->Current.RasterPos[3];
  2857.          break;
  2858.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2859.          params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][0];
  2860.          params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][1];
  2861.          params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][2];
  2862.          params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformSet][3];
  2863.          break;
  2864.       case GL_CURRENT_RASTER_POSITION_VALID:
  2865.          *params = (GLint) ctx->Current.RasterPosValid;
  2866.          break;
  2867.       case GL_CURRENT_TEXTURE_COORDS:
  2868.          params[0] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][0];
  2869.          params[1] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][1];
  2870.          params[2] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][2];
  2871.          params[3] = (GLint) ctx->Current.MultiTexCoord[texTransformSet][3];
  2872.          break;
  2873.       case GL_DEPTH_BIAS:
  2874.          *params = (GLint) ctx->Pixel.DepthBias;
  2875.          break;
  2876.       case GL_DEPTH_BITS:
  2877.          *params = ctx->Visual->DepthBits;
  2878.          break;
  2879.       case GL_DEPTH_CLEAR_VALUE:
  2880.          *params = (GLint) ctx->Depth.Clear;
  2881.          break;
  2882.       case GL_DEPTH_FUNC:
  2883.          *params = (GLint) ctx->Depth.Func;
  2884.          break;
  2885.       case GL_DEPTH_RANGE:
  2886.          params[0] = (GLint) ctx->Viewport.Near;
  2887.          params[1] = (GLint) ctx->Viewport.Far;
  2888.          break;
  2889.       case GL_DEPTH_SCALE:
  2890.          *params = (GLint) ctx->Pixel.DepthScale;
  2891.          break;
  2892.       case GL_DEPTH_TEST:
  2893.          *params = (GLint) ctx->Depth.Test;
  2894.          break;
  2895.       case GL_DEPTH_WRITEMASK:
  2896.          *params = (GLint) ctx->Depth.Mask;
  2897.          break;
  2898.       case GL_DITHER:
  2899.          *params = (GLint) ctx->Color.DitherFlag;
  2900.          break;
  2901.       case GL_DOUBLEBUFFER:
  2902.          *params = (GLint) ctx->Visual->DBflag;
  2903.          break;
  2904.       case GL_DRAW_BUFFER:
  2905.          *params = (GLint) ctx->Color.DrawBuffer;
  2906.          break;
  2907.       case GL_EDGE_FLAG:
  2908.          *params = (GLint) ctx->Current.EdgeFlag;
  2909.          break;
  2910.       case GL_FEEDBACK_BUFFER_SIZE:
  2911.          /* TODO: is this right?  Or, return number of entries in buffer? */
  2912.          *params = ctx->Feedback.BufferSize;
  2913.          break;
  2914.       case GL_FEEDBACK_BUFFER_TYPE:
  2915.          *params = ctx->Feedback.Type;
  2916.          break;
  2917.       case GL_FOG:
  2918.          *params = (GLint) ctx->Fog.Enabled;
  2919.          break;
  2920.       case GL_FOG_COLOR:
  2921.          params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
  2922.          params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
  2923.          params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
  2924.          params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
  2925.          break;
  2926.       case GL_FOG_DENSITY:
  2927.          *params = (GLint) ctx->Fog.Density;
  2928.          break;
  2929.       case GL_FOG_END:
  2930.          *params = (GLint) ctx->Fog.End;
  2931.          break;
  2932.       case GL_FOG_HINT:
  2933.          *params = (GLint) ctx->Hint.Fog;
  2934.          break;
  2935.       case GL_FOG_INDEX:
  2936.          *params = (GLint) ctx->Fog.Index;
  2937.          break;
  2938.       case GL_FOG_MODE:
  2939.          *params = (GLint) ctx->Fog.Mode;
  2940.          break;
  2941.       case GL_FOG_START:
  2942.          *params = (GLint) ctx->Fog.Start;
  2943.          break;
  2944.       case GL_FRONT_FACE:
  2945.          *params = (GLint) ctx->Polygon.FrontFace;
  2946.          break;
  2947.       case GL_GREEN_BIAS:
  2948.          *params = (GLint) ctx->Pixel.GreenBias;
  2949.          break;
  2950.       case GL_GREEN_BITS:
  2951.          *params = (GLint) ctx->Visual->GreenBits;
  2952.          break;
  2953.       case GL_GREEN_SCALE:
  2954.          *params = (GLint) ctx->Pixel.GreenScale;
  2955.          break;
  2956.       case GL_INDEX_BITS:
  2957.          *params = (GLint) ctx->Visual->IndexBits;
  2958.          break;
  2959.       case GL_INDEX_CLEAR_VALUE:
  2960.          *params = (GLint) ctx->Color.ClearIndex;
  2961.          break;
  2962.       case GL_INDEX_MODE:
  2963.          *params = ctx->Visual->RGBAflag ? 0 : 1;
  2964.          break;
  2965.       case GL_INDEX_OFFSET:
  2966.          *params = ctx->Pixel.IndexOffset;
  2967.          break;
  2968.       case GL_INDEX_SHIFT:
  2969.          *params = ctx->Pixel.IndexShift;
  2970.          break;
  2971.       case GL_INDEX_WRITEMASK:
  2972.          *params = (GLint) ctx->Color.IndexMask;
  2973.          break;
  2974.       case GL_LIGHT0:
  2975.       case GL_LIGHT1:
  2976.       case GL_LIGHT2:
  2977.       case GL_LIGHT3:
  2978.       case GL_LIGHT4:
  2979.       case GL_LIGHT5:
  2980.       case GL_LIGHT6:
  2981.       case GL_LIGHT7:
  2982.          *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  2983.          break;
  2984.       case GL_LIGHTING:
  2985.          *params = (GLint) ctx->Light.Enabled;
  2986.          break;
  2987.       case GL_LIGHT_MODEL_AMBIENT:
  2988.          params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
  2989.          params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
  2990.          params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
  2991.          params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
  2992.          break;
  2993.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  2994.          params[0] = (GLint) ctx->Light.Model.ColorControl;
  2995.          break;
  2996.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  2997.          *params = (GLint) ctx->Light.Model.LocalViewer;
  2998.          break;
  2999.       case GL_LIGHT_MODEL_TWO_SIDE:
  3000.          *params = (GLint) ctx->Light.Model.TwoSide;
  3001.          break;
  3002.       case GL_LINE_SMOOTH:
  3003.          *params = (GLint) ctx->Line.SmoothFlag;
  3004.          break;
  3005.       case GL_LINE_SMOOTH_HINT:
  3006.          *params = (GLint) ctx->Hint.LineSmooth;
  3007.          break;
  3008.       case GL_LINE_STIPPLE:
  3009.          *params = (GLint) ctx->Line.StippleFlag;
  3010.          break;
  3011.       case GL_LINE_STIPPLE_PATTERN:
  3012.          *params = (GLint) ctx->Line.StipplePattern;
  3013.          break;
  3014.       case GL_LINE_STIPPLE_REPEAT:
  3015.          *params = (GLint) ctx->Line.StippleFactor;
  3016.          break;
  3017.       case GL_LINE_WIDTH:
  3018.          *params = (GLint) ctx->Line.Width;
  3019.          break;
  3020.       case GL_LINE_WIDTH_GRANULARITY:
  3021.          *params = (GLint) LINE_WIDTH_GRANULARITY;
  3022.          break;
  3023.       case GL_LINE_WIDTH_RANGE:
  3024.          params[0] = (GLint) MIN_LINE_WIDTH;
  3025.          params[1] = (GLint) MAX_LINE_WIDTH;
  3026.          break;
  3027.       case GL_LIST_BASE:
  3028.          *params = (GLint) ctx->List.ListBase;
  3029.          break;
  3030.       case GL_LIST_INDEX:
  3031.          *params = (GLint) ctx->CurrentListNum;
  3032.          break;
  3033.       case GL_LIST_MODE:
  3034.          *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
  3035.                                   : (GLint) GL_COMPILE;
  3036.          break;
  3037.       case GL_INDEX_LOGIC_OP:
  3038.          *params = (GLint) ctx->Color.IndexLogicOpEnabled;
  3039.          break;
  3040.       case GL_COLOR_LOGIC_OP:
  3041.          *params = (GLint) ctx->Color.ColorLogicOpEnabled;
  3042.          break;
  3043.       case GL_LOGIC_OP_MODE:
  3044.          *params = (GLint) ctx->Color.LogicOp;
  3045.          break;
  3046.       case GL_MAP1_COLOR_4:
  3047.          *params = (GLint) ctx->Eval.Map1Color4;
  3048.          break;
  3049.       case GL_MAP1_GRID_DOMAIN:
  3050.          params[0] = (GLint) ctx->Eval.MapGrid1u1;
  3051.          params[1] = (GLint) ctx->Eval.MapGrid1u2;
  3052.          break;
  3053.       case GL_MAP1_GRID_SEGMENTS:
  3054.          *params = (GLint) ctx->Eval.MapGrid1un;
  3055.          break;
  3056.       case GL_MAP1_INDEX:
  3057.          *params = (GLint) ctx->Eval.Map1Index;
  3058.          break;
  3059.       case GL_MAP1_NORMAL:
  3060.          *params = (GLint) ctx->Eval.Map1Normal;
  3061.          break;
  3062.       case GL_MAP1_TEXTURE_COORD_1:
  3063.          *params = (GLint) ctx->Eval.Map1TextureCoord1;
  3064.          break;
  3065.       case GL_MAP1_TEXTURE_COORD_2:
  3066.          *params = (GLint) ctx->Eval.Map1TextureCoord2;
  3067.          break;
  3068.       case GL_MAP1_TEXTURE_COORD_3:
  3069.          *params = (GLint) ctx->Eval.Map1TextureCoord3;
  3070.          break;
  3071.       case GL_MAP1_TEXTURE_COORD_4:
  3072.          *params = (GLint) ctx->Eval.Map1TextureCoord4;
  3073.          break;
  3074.       case GL_MAP1_VERTEX_3:
  3075.          *params = (GLint) ctx->Eval.Map1Vertex3;
  3076.          break;
  3077.       case GL_MAP1_VERTEX_4:
  3078.          *params = (GLint) ctx->Eval.Map1Vertex4;
  3079.          break;
  3080.       case GL_MAP2_COLOR_4:
  3081.          *params = (GLint) ctx->Eval.Map2Color4;
  3082.          break;
  3083.       case GL_MAP2_GRID_DOMAIN:
  3084.          params[0] = (GLint) ctx->Eval.MapGrid2u1;
  3085.          params[1] = (GLint) ctx->Eval.MapGrid2u2;
  3086.          params[2] = (GLint) ctx->Eval.MapGrid2v1;
  3087.          params[3] = (GLint) ctx->Eval.MapGrid2v2;
  3088.          break;
  3089.       case GL_MAP2_GRID_SEGMENTS:
  3090.          params[0] = (GLint) ctx->Eval.MapGrid2un;
  3091.          params[1] = (GLint) ctx->Eval.MapGrid2vn;
  3092.          break;
  3093.       case GL_MAP2_INDEX:
  3094.          *params = (GLint) ctx->Eval.Map2Index;
  3095.          break;
  3096.       case GL_MAP2_NORMAL:
  3097.          *params = (GLint) ctx->Eval.Map2Normal;
  3098.          break;
  3099.       case GL_MAP2_TEXTURE_COORD_1:
  3100.          *params = (GLint) ctx->Eval.Map2TextureCoord1;
  3101.          break;
  3102.       case GL_MAP2_TEXTURE_COORD_2:
  3103.          *params = (GLint) ctx->Eval.Map2TextureCoord2;
  3104.          break;
  3105.       case GL_MAP2_TEXTURE_COORD_3:
  3106.          *params = (GLint) ctx->Eval.Map2TextureCoord3;
  3107.          break;
  3108.       case GL_MAP2_TEXTURE_COORD_4:
  3109.          *params = (GLint) ctx->Eval.Map2TextureCoord4;
  3110.          break;
  3111.       case GL_MAP2_VERTEX_3:
  3112.          *params = (GLint) ctx->Eval.Map2Vertex3;
  3113.          break;
  3114.       case GL_MAP2_VERTEX_4:
  3115.          *params = (GLint) ctx->Eval.Map2Vertex4;
  3116.          break;
  3117.       case GL_MAP_COLOR:
  3118.          *params = (GLint) ctx->Pixel.MapColorFlag;
  3119.          break;
  3120.       case GL_MAP_STENCIL:
  3121.          *params = (GLint) ctx->Pixel.MapStencilFlag;
  3122.          break;
  3123.       case GL_MATRIX_MODE:
  3124.          *params = (GLint) ctx->Transform.MatrixMode;
  3125.          break;
  3126.       case GL_MAX_ATTRIB_STACK_DEPTH:
  3127.          *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
  3128.          break;
  3129.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  3130.          *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  3131.          break;
  3132.       case GL_MAX_CLIP_PLANES:
  3133.          *params = (GLint) MAX_CLIP_PLANES;
  3134.          break;
  3135.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  3136.          *params = VB_MAX;
  3137.          break;
  3138.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  3139.          *params = VB_MAX;
  3140.          break;
  3141.       case GL_MAX_EVAL_ORDER:
  3142.          *params = (GLint) MAX_EVAL_ORDER;
  3143.          break;
  3144.       case GL_MAX_LIGHTS:
  3145.          *params = (GLint) MAX_LIGHTS;
  3146.          break;
  3147.       case GL_MAX_LIST_NESTING:
  3148.          *params = (GLint) MAX_LIST_NESTING;
  3149.          break;
  3150.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  3151.          *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
  3152.          break;
  3153.       case GL_MAX_NAME_STACK_DEPTH:
  3154.          *params = (GLint) MAX_NAME_STACK_DEPTH;
  3155.          break;
  3156.       case GL_MAX_PIXEL_MAP_TABLE:
  3157.          *params = (GLint) MAX_PIXEL_MAP_TABLE;
  3158.          break;
  3159.       case GL_MAX_PROJECTION_STACK_DEPTH:
  3160.          *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
  3161.          break;
  3162.       case GL_MAX_TEXTURE_SIZE:
  3163.          *params = max_texture_size(ctx);
  3164.          break;
  3165.       case GL_MAX_TEXTURE_STACK_DEPTH:
  3166.          *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
  3167.          break;
  3168.       case GL_MAX_VIEWPORT_DIMS:
  3169.          params[0] = (GLint) MAX_WIDTH;
  3170.          params[1] = (GLint) MAX_HEIGHT;
  3171.          break;
  3172.       case GL_MODELVIEW_MATRIX:
  3173.          for (i=0;i<16;i++) {
  3174.             params[i] = (GLint) ctx->ModelViewMatrix[i];
  3175.          }
  3176.          break;
  3177.       case GL_MODELVIEW_STACK_DEPTH:
  3178.          *params = (GLint) (ctx->ModelViewStackDepth + 1);
  3179.          break;
  3180.       case GL_NAME_STACK_DEPTH:
  3181.          *params = (GLint) ctx->Select.NameStackDepth;
  3182.          break;
  3183.       case GL_NORMALIZE:
  3184.          *params = (GLint) ctx->Transform.Normalize;
  3185.          break;
  3186.       case GL_PACK_ALIGNMENT:
  3187.          *params = ctx->Pack.Alignment;
  3188.          break;
  3189.       case GL_PACK_LSB_FIRST:
  3190.          *params = (GLint) ctx->Pack.LsbFirst;
  3191.          break;
  3192.       case GL_PACK_ROW_LENGTH:
  3193.          *params = ctx->Pack.RowLength;
  3194.          break;
  3195.       case GL_PACK_SKIP_PIXELS:
  3196.          *params = ctx->Pack.SkipPixels;
  3197.          break;
  3198.       case GL_PACK_SKIP_ROWS:
  3199.          *params = ctx->Pack.SkipRows;
  3200.          break;
  3201.       case GL_PACK_SWAP_BYTES:
  3202.          *params = (GLint) ctx->Pack.SwapBytes;
  3203.          break;
  3204.       case GL_PACK_SKIP_IMAGES_EXT:
  3205.          *params = ctx->Pack.SkipImages;
  3206.          break;
  3207.       case GL_PACK_IMAGE_HEIGHT_EXT:
  3208.          *params = ctx->Pack.ImageHeight;
  3209.          break;
  3210.       case GL_PERSPECTIVE_CORRECTION_HINT:
  3211.          *params = (GLint) ctx->Hint.PerspectiveCorrection;
  3212.          break;
  3213.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  3214.          *params = ctx->Pixel.MapAtoAsize;
  3215.          break;
  3216.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  3217.          *params = ctx->Pixel.MapBtoBsize;
  3218.          break;
  3219.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  3220.          *params = ctx->Pixel.MapGtoGsize;
  3221.          break;
  3222.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  3223.          *params = ctx->Pixel.MapItoAsize;
  3224.          break;
  3225.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  3226.          *params = ctx->Pixel.MapItoBsize;
  3227.          break;
  3228.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  3229.          *params = ctx->Pixel.MapItoGsize;
  3230.          break;
  3231.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  3232.          *params = ctx->Pixel.MapItoIsize;
  3233.          break;
  3234.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  3235.          *params = ctx->Pixel.MapItoRsize;
  3236.          break;
  3237.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  3238.          *params = ctx->Pixel.MapRtoRsize;
  3239.          break;
  3240.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  3241.          *params = ctx->Pixel.MapStoSsize;
  3242.          break;
  3243.       case GL_POINT_SIZE:
  3244.          *params = (GLint) ctx->Point.Size;
  3245.          break;
  3246.       case GL_POINT_SIZE_GRANULARITY:
  3247.          *params = (GLint) POINT_SIZE_GRANULARITY;
  3248.          break;
  3249.       case GL_POINT_SIZE_RANGE:
  3250.          params[0] = (GLint) MIN_POINT_SIZE;
  3251.          params[1] = (GLint) MAX_POINT_SIZE;
  3252.          break;
  3253.       case GL_POINT_SMOOTH:
  3254.          *params = (GLint) ctx->Point.SmoothFlag;
  3255.          break;
  3256.       case GL_POINT_SMOOTH_HINT:
  3257.          *params = (GLint) ctx->Hint.PointSmooth;
  3258.          break;
  3259.       case GL_POINT_SIZE_MIN_EXT:
  3260.          *params = (GLint) (ctx->Point.MinSize);
  3261.          break;
  3262.       case GL_POINT_SIZE_MAX_EXT:
  3263.          *params = (GLint) (ctx->Point.MaxSize);
  3264.          break;
  3265.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  3266.          *params = (GLint) (ctx->Point.Threshold);
  3267.          break;
  3268.       case GL_DISTANCE_ATTENUATION_EXT:
  3269.          params[0] = (GLint) (ctx->Point.Params[0]);
  3270.          params[1] = (GLint) (ctx->Point.Params[1]);
  3271.          params[2] = (GLint) (ctx->Point.Params[2]);
  3272.          break;
  3273.       case GL_POLYGON_MODE:
  3274.          params[0] = (GLint) ctx->Polygon.FrontMode;
  3275.          params[1] = (GLint) ctx->Polygon.BackMode;
  3276.          break;
  3277. #ifdef GL_EXT_polygon_offset
  3278.       case GL_POLYGON_OFFSET_BIAS_EXT:
  3279.          *params = (GLint) ctx->Polygon.OffsetUnits;
  3280.          break;
  3281. #endif
  3282.       case GL_POLYGON_OFFSET_FACTOR:
  3283.          *params = (GLint) ctx->Polygon.OffsetFactor;
  3284.          break;
  3285.       case GL_POLYGON_OFFSET_UNITS:
  3286.          *params = (GLint) ctx->Polygon.OffsetUnits;
  3287.          break;
  3288.       case GL_POLYGON_SMOOTH:
  3289.          *params = (GLint) ctx->Polygon.SmoothFlag;
  3290.          break;
  3291.       case GL_POLYGON_SMOOTH_HINT:
  3292.          *params = (GLint) ctx->Hint.PolygonSmooth;
  3293.          break;
  3294.       case GL_POLYGON_STIPPLE:
  3295.          *params = (GLint) ctx->Polygon.StippleFlag;
  3296.          break;
  3297.       case GL_PROJECTION_MATRIX:
  3298.          for (i=0;i<16;i++) {
  3299.             params[i] = (GLint) ctx->ProjectionMatrix[i];
  3300.          }
  3301.          break;
  3302.       case GL_PROJECTION_STACK_DEPTH:
  3303.          *params = (GLint) (ctx->ProjectionStackDepth + 1);
  3304.          break;
  3305.       case GL_READ_BUFFER:
  3306.          *params = (GLint) ctx->Pixel.ReadBuffer;
  3307.          break;
  3308.       case GL_RED_BIAS:
  3309.          *params = (GLint) ctx->Pixel.RedBias;
  3310.          break;
  3311.       case GL_RED_BITS:
  3312.          *params = (GLint) ctx->Visual->RedBits;
  3313.          break;
  3314.       case GL_RED_SCALE:
  3315.          *params = (GLint) ctx->Pixel.RedScale;
  3316.          break;
  3317.       case GL_RENDER_MODE:
  3318.          *params = (GLint) ctx->RenderMode;
  3319.          break;
  3320.       case GL_RGBA_MODE:
  3321.          *params = (GLint) ctx->Visual->RGBAflag;
  3322.          break;
  3323.       case GL_SCISSOR_BOX:
  3324.          params[0] = (GLint) ctx->Scissor.X;
  3325.          params[1] = (GLint) ctx->Scissor.Y;
  3326.          params[2] = (GLint) ctx->Scissor.Width;
  3327.          params[3] = (GLint) ctx->Scissor.Height;
  3328.          break;
  3329.       case GL_SCISSOR_TEST:
  3330.          *params = (GLint) ctx->Scissor.Enabled;
  3331.          break;
  3332.       case GL_SELECTION_BUFFER_SIZE:
  3333.          *params = (GLint) ctx->Select.BufferSize;
  3334.          break;
  3335.       case GL_SHADE_MODEL:
  3336.          *params = (GLint) ctx->Light.ShadeModel;
  3337.          break;
  3338.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  3339.          *params = (GLint) ctx->Texture.SharedPalette;
  3340.          break;
  3341.       case GL_STENCIL_BITS:
  3342.          *params = ctx->Visual->StencilBits;
  3343.          break;
  3344.       case GL_STENCIL_CLEAR_VALUE:
  3345.          *params = (GLint) ctx->Stencil.Clear;
  3346.          break;
  3347.       case GL_STENCIL_FAIL:
  3348.          *params = (GLint) ctx->Stencil.FailFunc;
  3349.          break;
  3350.       case GL_STENCIL_FUNC:
  3351.          *params = (GLint) ctx->Stencil.Function;
  3352.          break;
  3353.       case GL_STENCIL_PASS_DEPTH_FAIL:
  3354.          *params = (GLint) ctx->Stencil.ZFailFunc;
  3355.          break;
  3356.       case GL_STENCIL_PASS_DEPTH_PASS:
  3357.          *params = (GLint) ctx->Stencil.ZPassFunc;
  3358.          break;
  3359.       case GL_STENCIL_REF:
  3360.          *params = (GLint) ctx->Stencil.Ref;
  3361.          break;
  3362.       case GL_STENCIL_TEST:
  3363.          *params = (GLint) ctx->Stencil.Enabled;
  3364.          break;
  3365.       case GL_STENCIL_VALUE_MASK:
  3366.          *params = (GLint) ctx->Stencil.ValueMask;
  3367.          break;
  3368.       case GL_STENCIL_WRITEMASK:
  3369.          *params = (GLint) ctx->Stencil.WriteMask;
  3370.          break;
  3371.       case GL_STEREO:
  3372.          *params = 0;  /* TODO */
  3373.          break;
  3374.       case GL_SUBPIXEL_BITS:
  3375.          *params = 0;  /* TODO */
  3376.          break;
  3377.       case GL_TEXTURE_1D:
  3378.          {
  3379.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  3380.             *params = (ctx->Texture.Enabled & bit) ? 1 : 0;
  3381.          }
  3382.          break;
  3383.       case GL_TEXTURE_2D:
  3384.          {
  3385.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  3386.             *params = (ctx->Texture.Enabled & bit) ? 1 : 0;
  3387.          }
  3388.          break;
  3389.       case GL_TEXTURE_3D:
  3390.          {
  3391.             GLuint bit = TEXTURE0_3D << (texSet * 4);
  3392.             *params = (ctx->Texture.Enabled & bit) ? 1 : 0;
  3393.          }
  3394.          break;
  3395.       case GL_TEXTURE_BINDING_1D:
  3396.          *params = textureSet->Current1D->Name;
  3397.           break;
  3398.       case GL_TEXTURE_BINDING_2D:
  3399.          *params = textureSet->Current2D->Name;
  3400.           break;
  3401.       case GL_TEXTURE_BINDING_3D:
  3402.          *params = textureSet->Current3D->Name;
  3403.           break;
  3404.       case GL_TEXTURE_ENV_COLOR:
  3405.          params[0] = FLOAT_TO_INT( textureSet->EnvColor[0] );
  3406.          params[1] = FLOAT_TO_INT( textureSet->EnvColor[1] );
  3407.          params[2] = FLOAT_TO_INT( textureSet->EnvColor[2] );
  3408.          params[3] = FLOAT_TO_INT( textureSet->EnvColor[3] );
  3409.          break;
  3410.       case GL_TEXTURE_ENV_MODE:
  3411.          *params = (GLint) textureSet->EnvMode;
  3412.          break;
  3413.       case GL_TEXTURE_GEN_S:
  3414.          *params = (textureSet->TexGenEnabled & S_BIT) ? 1 : 0;
  3415.          break;
  3416.       case GL_TEXTURE_GEN_T:
  3417.          *params = (textureSet->TexGenEnabled & T_BIT) ? 1 : 0;
  3418.          break;
  3419.       case GL_TEXTURE_GEN_R:
  3420.          *params = (textureSet->TexGenEnabled & R_BIT) ? 1 : 0;
  3421.          break;
  3422.       case GL_TEXTURE_GEN_Q:
  3423.          *params = (textureSet->TexGenEnabled & Q_BIT) ? 1 : 0;
  3424.          break;
  3425.       case GL_TEXTURE_MATRIX:
  3426.          for (i=0;i<16;i++) {
  3427.             params[i] = (GLint) ctx->TextureMatrix[texTransformSet][i];
  3428.          }
  3429.          break;
  3430.       case GL_TEXTURE_STACK_DEPTH:
  3431.          *params = (GLint) (ctx->TextureStackDepth[texTransformSet] + 1);
  3432.          break;
  3433.       case GL_UNPACK_ALIGNMENT:
  3434.          *params = ctx->Unpack.Alignment;
  3435.          break;
  3436.       case GL_UNPACK_LSB_FIRST:
  3437.          *params = (GLint) ctx->Unpack.LsbFirst;
  3438.          break;
  3439.       case GL_UNPACK_ROW_LENGTH:
  3440.          *params = ctx->Unpack.RowLength;
  3441.          break;
  3442.       case GL_UNPACK_SKIP_PIXELS:
  3443.          *params = ctx->Unpack.SkipPixels;
  3444.          break;
  3445.       case GL_UNPACK_SKIP_ROWS:
  3446.          *params = ctx->Unpack.SkipRows;
  3447.          break;
  3448.       case GL_UNPACK_SWAP_BYTES:
  3449.          *params = (GLint) ctx->Unpack.SwapBytes;
  3450.          break;
  3451.       case GL_UNPACK_SKIP_IMAGES_EXT:
  3452.          *params = ctx->Unpack.SkipImages;
  3453.          break;
  3454.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  3455.          *params = ctx->Unpack.ImageHeight;
  3456.          break;
  3457.       case GL_VIEWPORT:
  3458.          params[0] = (GLint) ctx->Viewport.X;
  3459.          params[1] = (GLint) ctx->Viewport.Y;
  3460.          params[2] = (GLint) ctx->Viewport.Width;
  3461.          params[3] = (GLint) ctx->Viewport.Height;
  3462.          break;
  3463.       case GL_ZOOM_X:
  3464.          *params = (GLint) ctx->Pixel.ZoomX;
  3465.          break;
  3466.       case GL_ZOOM_Y:
  3467.          *params = (GLint) ctx->Pixel.ZoomY;
  3468.          break;
  3469.       case GL_VERTEX_ARRAY_SIZE:
  3470.          *params = ctx->Array.VertexSize;
  3471.          break;
  3472.       case GL_VERTEX_ARRAY_TYPE:
  3473.          *params = ctx->Array.VertexType;
  3474.          break;
  3475.       case GL_VERTEX_ARRAY_STRIDE:
  3476.          *params = ctx->Array.VertexStride;
  3477.          break;
  3478.       case GL_VERTEX_ARRAY_COUNT_EXT:
  3479.          *params = 0;
  3480.          break;
  3481.       case GL_NORMAL_ARRAY_TYPE:
  3482.          *params = ctx->Array.NormalType;
  3483.          break;
  3484.       case GL_NORMAL_ARRAY_STRIDE:
  3485.          *params = ctx->Array.NormalStride;
  3486.          break;
  3487.       case GL_NORMAL_ARRAY_COUNT_EXT:
  3488.          *params = 0;
  3489.          break;
  3490.       case GL_COLOR_ARRAY_SIZE:
  3491.          *params = ctx->Array.ColorSize;
  3492.          break;
  3493.       case GL_COLOR_ARRAY_TYPE:
  3494.          *params = ctx->Array.ColorType;
  3495.          break;
  3496.       case GL_COLOR_ARRAY_STRIDE:
  3497.          *params = ctx->Array.ColorStride;
  3498.          break;
  3499.       case GL_COLOR_ARRAY_COUNT_EXT:
  3500.          *params = 0;
  3501.          break;
  3502.       case GL_INDEX_ARRAY_TYPE:
  3503.          *params = ctx->Array.IndexType;
  3504.          break;
  3505.       case GL_INDEX_ARRAY_STRIDE:
  3506.          *params = ctx->Array.IndexStride;
  3507.          break;
  3508.       case GL_INDEX_ARRAY_COUNT_EXT:
  3509.          *params = 0;
  3510.          break;
  3511.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  3512.          *params = ctx->Array.TexCoordSize[texSet];
  3513.          break;
  3514.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  3515.          *params = ctx->Array.TexCoordType[texSet];
  3516.          break;
  3517.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  3518.          *params = ctx->Array.TexCoordStride[texSet];
  3519.          break;
  3520.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  3521.          *params = 0;
  3522.          break;
  3523.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  3524.          *params = ctx->Array.EdgeFlagStride;
  3525.          break;
  3526.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  3527.          *params = 0;
  3528.          break;
  3529.  
  3530.       /* GL_SGIS_multitexture */
  3531.       case GL_SELECTED_TEXTURE_SGIS:
  3532.          *params = ctx->Texture.CurrentSet;
  3533.          break;
  3534.       case GL_SELECTED_TEXTURE_COORD_SET_SGIS:
  3535.          *params = ctx->TexCoordSet;
  3536.          break;
  3537.       case GL_MAX_TEXTURES_SGIS:
  3538.          *params = max_textures(ctx);
  3539.          break;
  3540.  
  3541.       /* GL_EXT_multitexture */
  3542.       case GL_SELECTED_TEXTURE_EXT:
  3543.          *params = ctx->Texture.CurrentSet;
  3544.          break;
  3545.       case GL_SELECTED_TEXTURE_COORD_SET_EXT:
  3546.          *params = ctx->TexCoordSet;
  3547.          break;
  3548.       case GL_SELECTED_TEXTURE_TRANSFORM_EXT:
  3549.          *params = ctx->Texture.CurrentTransformSet;
  3550.          break;
  3551.       case GL_MAX_TEXTURES_EXT:
  3552.          *params = max_textures(ctx);
  3553.          break;
  3554.       case GL_MAX_TEXTURE_COORD_SETS_EXT:
  3555.          *params = MAX_TEX_COORD_SETS;
  3556.          break;
  3557.  
  3558.       default:
  3559.          gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
  3560.    }
  3561. }
  3562.  
  3563.  
  3564.  
  3565. void gl_GetPointerv( GLcontext *ctx, GLenum pname, GLvoid **params )
  3566. {
  3567.    GLuint texSet = ctx->Texture.CurrentSet;
  3568.    /*GLuint texTransformSet = ctx->Texture.CurrentTransformSet;*/
  3569.    switch (pname) {
  3570.       case GL_VERTEX_ARRAY_POINTER:
  3571.          *params = ctx->Array.VertexPtr;
  3572.          break;
  3573.       case GL_NORMAL_ARRAY_POINTER:
  3574.          *params = ctx->Array.NormalPtr;
  3575.          break;
  3576.       case GL_COLOR_ARRAY_POINTER:
  3577.          *params = ctx->Array.ColorPtr;
  3578.          break;
  3579.       case GL_INDEX_ARRAY_POINTER:
  3580.          *params = ctx->Array.IndexPtr;
  3581.          break;
  3582.       case GL_TEXTURE_COORD_ARRAY_POINTER:
  3583.          *params = ctx->Array.TexCoordPtr[texSet];
  3584.          break;
  3585.       case GL_EDGE_FLAG_ARRAY_POINTER:
  3586.          *params = ctx->Array.EdgeFlagPtr;
  3587.          break;
  3588.       case GL_FEEDBACK_BUFFER_POINTER:
  3589.          *params = ctx->Feedback.Buffer;
  3590.          break;
  3591.       case GL_SELECTION_BUFFER_POINTER:
  3592.          *params = ctx->Select.Buffer;
  3593.          break;
  3594.       default:
  3595.          gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
  3596.          return;
  3597.    }
  3598. }
  3599.